# ArcKit v4.1.1: GitHub Copilot, Vendor Scoring, and Blast Radius Analysis

ArcKit v4.1.1 lands a sixth distribution format, brings structured procurement workflows into the governance toolkit, and adds the ability to trace how a single change ripples across an entire architecture. It also introduces a session memory system that turns each working session into institutional knowledge.

Three weeks after v4.0.0 restructured ArcKit into a multi-platform architecture with first-class Codex and Gemini support, v4.1.1 extends that foundation in two directions: a new platform (GitHub Copilot) and deeper governance capabilities that make the existing 57 commands more interconnected.

Here's what's new.

## GitHub Copilot: The Sixth Platform

ArcKit now generates prompt files and custom agents for GitHub Copilot in VS Code. This is the sixth distribution format, joining Claude Code, Gemini CLI, Codex CLI, OpenCode CLI, and the Python CLI.

The Copilot extension ships 60 prompt files in the `.prompt.md` format that Copilot's extensibility system expects, plus six custom agents that mirror ArcKit's research agents. Each prompt is generated by the same converter pipeline that produces Codex skills and Gemini TOML commands, meaning Copilot users get exactly the same governance prompts as every other platform, adapted to Copilot's native format.

The practical difference is where the commands live. In Claude Code, you type `/arckit.requirements`. In Codex CLI, you invoke the `$arckit-requirements` skill. In Gemini CLI, it's `/arckit:requirements`. In Copilot, you reference the `arckit-requirements` prompt. Different invocation syntax, identical governance output.

Installation happens through the CLI: `arckit init --ai copilot` scaffolds the project structure with Copilot-specific files. A `copilot-instructions.md` file provides Copilot with project-level context about ArcKit's conventions, template system, and document control standards.

The extension also includes a dedicated documentation tab. Both `docs/index.html` and the getting-started guide now feature a Copilot platform card alongside the existing Claude Code, Gemini, Codex, and OpenCode tabs, giving new users a clear onboarding path for their specific environment.

## Vendor Scoring: From Evaluation to Decision

The `/arckit.score` command fills a gap that became obvious once teams started using ArcKit for full procurement cycles. The existing `/arckit.evaluate` command creates evaluation frameworks with weighted criteria. The existing `/arckit.research` agent conducts market research and vendor analysis. But between evaluation framework and final recommendation, there was no structured way to actually score vendors against criteria and compare them.

Now there is. The scoring system works through three sub-actions.

**Scoring a vendor** reads the project's evaluation criteria from its EVAL artifact, extracts the criteria weights and categories, then scores a vendor's proposal against each criterion on a 0–3 rubric: Not Met, Partially Met, Met, or Exceeds. Every score requires evidence from the vendor's proposal. No evidence, no score. The results are written to a `scores.json` file in the vendor's directory within the project, creating a persistent, machine-readable scoring record.

**Comparing vendors** reads all scored vendors from `scores.json` and generates a side-by-side comparison table with weighted totals. But it goes further than a simple ranking. A sensitivity analysis varies each criterion's weight by plus or minus ten percent to identify which criteria are decisive. If swapping ten percent of weight between Technical Capability and Cost changes the winner, the comparison flags that. This is the kind of analysis that procurement boards need and rarely get.

**Auditing scores** produces a chronological trail of all scoring activity: who scored which vendor, when, and what the weighted result was. For public sector procurement where audit trails are mandatory, this turns what would otherwise be a spreadsheet exercise into a versioned, git-tracked record.

The scoring data lives as JSON rather than markdown because it's designed to be consumed programmatically. A dashboard view, vendor comparison charts, or integration with procurement management tools all become possible when scores are structured data rather than prose in a document.

The handoff chain is deliberate too. If no evaluation framework exists, the command directs you to `/arckit.evaluate` first. Once a vendor is selected, it suggests `/arckit.sow` to generate a Statement of Work. Scoring sits precisely where it should in the procurement workflow: after evaluation criteria are defined, before contracts are drafted.

## Impact Analysis: Understanding Blast Radius

The `/arckit.impact` command answers the question that every architecture governance team needs answered before approving a change: what else does this affect?

Architecture documents don't exist in isolation. A business requirement (BR-003, say, "All customer data must reside within UK data centres") might be referenced by an Architecture Decision Record justifying the choice of cloud provider, which is in turn referenced by a High-Level Design showing deployment topology, which feeds into a Secure by Design assessment and a Data Protection Impact Assessment. Change BR-003, and you potentially need to revisit every document in that chain.

Impact analysis performs reverse dependency tracing. Given a document ID or requirement ID, it walks backwards through all cross-references to build an impact chain showing exactly which documents are affected and at what severity. The output categorises impacts into three tiers: HIGH for compliance and governance documents that may need formal re-assessment, MEDIUM for architecture design documents that may need updates, and LOW for planning documents where a review is recommended but not urgent.

The command doesn't just list affected documents. It recommends specific ArcKit commands to run for each high-severity impact. A SECD document in the impact chain? Run `/arckit.secure`. A DPIA affected? Run `/arckit.dpia`. The impact analysis connects directly back to ArcKit's governance commands, turning a change notification into an actionable remediation plan.

### The Impact Hook: Pre-Processing at Scale

What makes impact analysis fast is what happens before the command runs. The `impact-scan.mjs` hook fires on the user's prompt submission, before the AI model even sees the request. It scans every project artifact, extracts cross-references between documents, identifies shared requirement IDs, and builds a complete dependency graph. By the time the impact command starts executing, the graph is already built and injected into the context as structured JSON.

This is the same pre-processing pattern that powers ArcKit's health check and traceability commands. The hook does the expensive filesystem work upfront, and the command operates purely on the pre-computed data. The result is that impact analysis across a project with dozens of architecture artifacts completes without the hundreds of file reads that would otherwise be necessary.

## Search: Finding What You've Built

The `/arckit.search` command provides keyword, type, and requirement ID search across all project artifacts. As projects grow beyond a handful of documents, finding where a specific technology decision was recorded or which documents reference a particular requirement becomes increasingly difficult. Search solves this directly.

The command supports multiple query modes. Plain text searches across document titles, content previews, and control fields. Type filters (`--type=ADR`) narrow results to specific artifact categories. Project filters (`--project=001`) scope to a single project. Requirement ID filters (`--id=BR-003`) find every document that references a specific requirement. These combine naturally: `PostgreSQL --type=ADR --project=001` finds ADRs in project 001 that mention PostgreSQL.

Results are relevance-scored, with title matches weighted highest (10 points), followed by control field matches (5 points), content preview matches (3 points), and filename matches (2 points). Exact matches score double. The top three results include content previews with the matching text quoted, giving architects enough context to decide whether to open the full document.

Like impact analysis, search relies on a pre-processing hook that indexes all project artifacts before the command executes. The search command operates on the pre-built index rather than scanning files in real time.

## Session Learner: Institutional Memory

The session learner is a pair of hooks that turn each ArcKit working session into a knowledge artifact.

When a session ends, the `session-learner.mjs` Stop hook fires. It analyses all git commits made since the last recorded session, groups the artifacts by project number and category, and appends a structured summary to `.arckit/memory/sessions.md`. The summary captures what was worked on, which commands were used, and what artifacts were created or modified.

When the next session starts, the `arckit-session.mjs` SessionStart hook reads the session history and injects it into the context. The AI assistant immediately knows what was done in previous sessions without the architect needing to explain context. If yesterday's session generated a requirements document and three ADRs for project 001, today's session starts with that knowledge already present.

Timestamp tracking via `.arckit/memory/.last-session` ensures clean boundaries between sessions. There's no overlap and no gaps. Each session captures exactly its own commits.

This matters most for teams where architecture work spans multiple sessions across days or weeks. The session learner provides continuity without requiring manual notes or briefing documents. It's institutional memory, automated.

## The Command Count: 60

With the addition of search, score, and impact, ArcKit now ships 60 slash commands across six platforms. The converter pipeline handles the multiplication: one command definition produces six native format outputs. A single `python scripts/converter.py` run generates all 60 Copilot prompts, 60 Codex skills, 60 Gemini TOML commands, and 60 OpenCode commands from the 60 Claude Code source definitions.

The six agents remain Claude Code and Copilot specific in their autonomous execution model, but their full prompts are inlined into the Codex, Gemini, and OpenCode equivalents so that every platform gets the same research depth through its own execution approach.

## Upgrading

For **Claude Code** users with the marketplace plugin: updates are automatic. The plugin pulls from the marketplace repository and picks up v4.1.1 on your next session.

For **Copilot** users: run `arckit init --ai copilot` in your project to scaffold the Copilot extension files. If you already have an ArcKit project, the init command will add the Copilot-specific files without disturbing existing artifacts.

For **Codex**, **Gemini**, and **OpenCode** users: the extensions are updated through their respective distribution channels, all generated from the same v4.1.1 source.

## What's Next

The SDG mono-repo creation script is in development on a feature branch, expanding ArcKit's project scaffolding capabilities. The handoff system introduced in v4.0.0 continues to grow as each new command declares its logical next steps, gradually building a workflow graph that guides architects through governance processes rather than leaving them to guess which command to run next.

ArcKit is open source at [github.com/tractorjuice/arc-kit](https://github.com/tractorjuice/arc-kit). Join the conversation in the [ArcKit LinkedIn Group](https://www.linkedin.com/groups/17641034/) or the [ArcKit Discord](https://discord.gg/HsA4Y3hQ4).

<!-- arckit:related-articles -->
## Related Articles

- [ArcKit v4: First-Class Codex and Gemini Support](article-viewer.html?a=2026-03-08-v4-codex-gemini-support)
- [ArcKit v5.0.0: One Toolkit, Seven Plugins, Install Only What You Need](article-viewer.html?a=2026-05-18-arckit-v5-plugin-split)
- [From ArcKit to McKinsey-Style Infographics in an Afternoon](article-viewer.html?a=2026-04-27-mckinsey-decks-from-arckit)
- [Your Architecture Documents Are Connected — Now You Can See How](article-viewer.html?a=2026-03-12-document-map-medium)

<!-- arckit:community-block -->
## Join the ArcKit Community

- **Discord** — real-time conversation, help with commands, and what people are building: [discord.gg/HsA4Y3hQ4](https://discord.gg/HsA4Y3hQ4)
- **LinkedIn Group** — announcements, case studies, and longer-form discussion: [linkedin.com/groups/17641034](https://www.linkedin.com/groups/17641034/)
- **GitHub** — code, issues, and contributions: [github.com/tractorjuice/arc-kit](https://github.com/tractorjuice/arc-kit)