@vpxa/aikit 0.1.348 → 0.1.350

package/scaffold/dist/adapters/hermes-agent.mjs

@@ -50,5 +50,5 @@ Hermes provides native tools (\`terminal\`, \`read_file\`, \`write_file\`, \`pat
 plus AI Kit MCP tools (\`mcp_aikit_search\`, \`mcp_aikit_knowledge\`, etc.) for code analysis, memory, and context compression.
 
 See \`AGENTS.md\` (in Hermes config directory) for complete tool usage guidance.
-`}function E(){return[`# aikit — Hermes Agent Instructions`,``,"This file is generated from `scaffold/definitions/`. Do not edit directly.",``,o,``,`## Tool Routing Rules`,``,`Hermes provides native tools (terminal, read_file, write_file, patch, search_files, delegate_task, etc.)`,`plus AI Kit MCP tools (mcp_aikit_*) for code analysis, memory, and context compression.`,``,`### When to Use AI Kit Tools`,``,`| Instead of | Use AI Kit Tool | Why |`,`|-----------|----------------|-----|`,"| `grep` / `rg` | `mcp_aikit_search` or `mcp_aikit_find` | Hybrid search across all indexed content |","| `cat` for understanding | `mcp_aikit_file_summary` or `mcp_aikit_compact` | 10x fewer tokens than raw file reads |","| Running tests in terminal | `mcp_aikit_test_run` | Structured output — no shell needed |","| `tsc` / `biome` in terminal | `mcp_aikit_check` | Typecheck + lint combined |","| Web search | `mcp_aikit_web_search` | Fans out to multiple keyless providers |",``,m(),``,a,``].join(`
+`}function E(){return[`# aikit — Hermes Agent Instructions`,``,"This file is generated from `scaffold/definitions/`. Do not edit directly.",``,o,``,`## Tool Routing Rules`,``,`Hermes provides native tools (terminal, read_file, write_file, patch, search_files, delegate_task, etc.)`,`plus AI Kit MCP tools (mcp_aikit_*) for code analysis, memory, and context compression.`,``,`### When to Use AI Kit Tools`,``,`| Instead of | Use AI Kit Tool | Why |`,`|-----------|----------------|-----|`,"| `grep` / `rg` | `mcp_aikit_search` or `mcp_aikit_find` | Hybrid search across all indexed content |","| `cat` for understanding | `mcp_aikit_file_summary` | T1=structure, T2=structure+content — 10x fewer tokens than raw file reads |","| Running tests in terminal | `mcp_aikit_test_run` | Structured output — no shell needed |","| `tsc` / `biome` in terminal | `mcp_aikit_check` | Typecheck + lint combined |","| Web search | `mcp_aikit_web_search` | Fans out to multiple keyless providers |",``,m(),``,a,``].join(`
 `)}function D(){let t=[];if(p().length===0)throw Error(`Executable hooks are not configured.`);t.push({path:`hermes-instructions.md`,content:E()});for(let[r,i]of Object.entries(e))if(i.variants)for(let e of n[r]||[])t.push({path:`agents/${r}-${e}.agent.md`,content:S(r,e,i)});else t.push({path:`agents/${r}.agent.md`,content:C(r,i)});for(let[e,n]of Object.entries(c))t.push({path:`agents/templates/${e}.md`,content:`${n}\n`});t.push({path:`agents/README.md`,content:T()});for(let[e,n]of Object.entries(i))t.push({path:`prompts/aikit-${e}.prompt.md`,content:w(e,n)});let r=f(`hermes`,`~/.hermes/hooks/scripts`);return t.push(...r.map(e=>({path:`hooks/${e.path}`,content:e.content}))),t}export{D as generateHermesAgent};

package/scaffold/dist/adapters/hermes.mjs

@@ -1,4 +1,4 @@
-import{AGENTS as e}from"../definitions/agents.mjs";import{AGENT_BODIES as t}from"../definitions/bodies.mjs";import{HOOKS as n}from"../definitions/hooks.mjs";import{PROMPTS as r}from"../definitions/prompts.mjs";import{PROTOCOLS as i}from"../definitions/protocols.mjs";import{buildAgentTable as a,buildCompactAgentTable as o,buildFlowSection as s,buildHooksSection as c,buildPromptSections as l,buildSkillsSection as u,lowerFirst as d}from"./_shared.mjs";const f=s({flowTool:`flow`,isLifecycleOwner:!0}),p=s({flowTool:`flow`,isLifecycleOwner:!1});function m(e,n){let r=t[e];return typeof r==`function`?r(n):r||``}function h(e){let t=[];e.extraBody&&t.push(e.extraBody),e.sharedBase&&i[e.sharedBase]&&t.push(i[e.sharedBase]);for(let n of e.sharedProtocols||[])i[n]&&t.push(i[n]);return t}function g(){let t=a(e),i=o(e),s=l(r),u=[];for(let[t,n]of Object.entries(e)){let e=m(t,i);if(n.variants){for(let[r,i]of Object.entries(n.variants)){let a=`${t}-${r}`;u.push(_(a,{...n,description:i.description||n.description,identity:i.identity,bodyAddendum:i.bodyAddendum},e))}continue}u.push(_(t,n,e))}return[`# AI Kit — Hermes Agent Instructions`,``,"This project uses **AI Kit** (`@vpxa/aikit`), a local-first MCP server that provides search,",`code analysis, persistent memory, context compression, and guided development flows.`,``,`The AI Kit MCP server is registered in your Hermes config and its 64 tools are available`,"as `mcp_aikit_*` tool calls in every conversation.",``,`## MCP Server`,``,"Server name: `aikit`","Configured via `hermes mcp add` (user-level). Tools are auto-discovered at session start.",``,`## Skills-First Rule`,``,`**Before starting ANY task, check available skills.** If a skill matches your task domain`,`— load it first. Skills contain domain-specific patterns, templates, and constraints.`,``,`## Available Tools (64)`,``,`AI Kit provides tools across the following categories:`,``,`| Category | Tools |`,`|----------|-------|`,"| **Search & Discovery** | `search`, `find`, `symbol`, `trace`, `lookup`, `scope_map`, `file_summary`, `dead_symbols` |","| **Code Analysis** | `analyze`, `blast_radius`, `audit`, `graph`, `health`, `check` |","| **Context Compression** | `compact`, `digest`, `stratum_card` |","| **Memory & Knowledge** | `knowledge`, `remember`, `read`, `update`, `forget`, `list`, `stash` |","| **FORGE Quality Gates** | `forge_classify`, `forge_ground`, `evidence_map`, `compliance_score` |","| **Development Workflows** | `flow`, `onboard`, `reindex`, `status`, `guide`, `config` |","| **Testing & Build** | `test_run`, `parse_output`, `check`, `eval` |","| **Code Manipulation** | `rename`, `codemod`, `data_transform`, `diff_parse`, `git_context`, `replay` |","| **Web & HTTP** | `web_search`, `web_fetch`, `http` |","| **Present & Visualize** | `present`, `signal`, `session_digest` |","| **Sandbox & Process** | `process`, `watch`, `workset`, `lane`, `queue`, `restore`, `delegate` |","| **Utilities** | `encode`, `regex_test`, `measure`, `changelog`, `schema_validate`, `env`, `time` |","| **Browser** | `browser` |",``,`## Important: Prefer AI Kit Tools Over Generic Shell Commands`,``,`When working in this project, use AI Kit MCP tools instead of generic alternatives:`,``,`| Instead of | Use AI Kit Tool | Why |`,`|-----------|----------------|-----|`,"| `grep` / `rg` | `mcp_aikit_search` or `mcp_aikit_find` | Hybrid search (vector + keyword + BM25) across all indexed content |","| `read_file` for understanding | `mcp_aikit_file_summary` or `mcp_aikit_compact` | Structure, exports, imports — 10x fewer tokens than raw file reads |","| `cd` + `ls` | `mcp_aikit_analyze` | Structural analysis with tree views |","| Running tests in terminal | `mcp_aikit_test_run` | Structured test output — no shell needed |","| `tsc` / `biome` in terminal | `mcp_aikit_check` | Typecheck + lint combined |","| Web search | `mcp_aikit_web_search` | Fans out to multiple keyless providers |",``,`## Agents`,``,t,``,`## Agent Instructions`,``,u.join(`
+import{AGENTS as e}from"../definitions/agents.mjs";import{AGENT_BODIES as t}from"../definitions/bodies.mjs";import{HOOKS as n}from"../definitions/hooks.mjs";import{PROMPTS as r}from"../definitions/prompts.mjs";import{PROTOCOLS as i}from"../definitions/protocols.mjs";import{buildAgentTable as a,buildCompactAgentTable as o,buildFlowSection as s,buildHooksSection as c,buildPromptSections as l,buildSkillsSection as u,lowerFirst as d}from"./_shared.mjs";const f=s({flowTool:`flow`,isLifecycleOwner:!0}),p=s({flowTool:`flow`,isLifecycleOwner:!1});function m(e,n){let r=t[e];return typeof r==`function`?r(n):r||``}function h(e){let t=[];e.extraBody&&t.push(e.extraBody),e.sharedBase&&i[e.sharedBase]&&t.push(i[e.sharedBase]);for(let n of e.sharedProtocols||[])i[n]&&t.push(i[n]);return t}function g(){let t=a(e),i=o(e),s=l(r),u=[];for(let[t,n]of Object.entries(e)){let e=m(t,i);if(n.variants){for(let[r,i]of Object.entries(n.variants)){let a=`${t}-${r}`;u.push(_(a,{...n,description:i.description||n.description,identity:i.identity,bodyAddendum:i.bodyAddendum},e))}continue}u.push(_(t,n,e))}return[`# AI Kit — Hermes Agent Instructions`,``,"This project uses **AI Kit** (`@vpxa/aikit`), a local-first MCP server that provides search,",`code analysis, persistent memory, context compression, and guided development flows.`,``,`The AI Kit MCP server is registered in your Hermes config and its 64 tools are available`,"as `mcp_aikit_*` tool calls in every conversation.",``,`## MCP Server`,``,"Server name: `aikit`","Configured via `hermes mcp add` (user-level). Tools are auto-discovered at session start.",``,`## Skills-First Rule`,``,`**Before starting ANY task, check available skills.** If a skill matches your task domain`,`— load it first. Skills contain domain-specific patterns, templates, and constraints.`,``,`## Available Tools (64)`,``,`AI Kit provides tools across the following categories:`,``,`| Category | Tools |`,`|----------|-------|`,"| **Search & Discovery** | `search`, `find`, `symbol`, `trace`, `lookup`, `scope_map`, `file_summary`, `dead_symbols` |","| **Code Analysis** | `analyze`, `blast_radius`, `audit`, `graph`, `health`, `check` |","| **Context Compression** | `file_summary`, `digest` |","| **Memory & Knowledge** | `knowledge`, `remember`, `read`, `update`, `forget`, `list`, `stash` |","| **FORGE Quality Gates** | `forge_classify`, `forge_ground`, `evidence_map`, `compliance_score` |","| **Development Workflows** | `flow`, `onboard`, `reindex`, `status`, `guide`, `config` |","| **Testing & Build** | `test_run`, `parse_output`, `check`, `eval` |","| **Code Manipulation** | `rename`, `codemod`, `data_transform`, `diff_parse`, `git_context`, `replay` |","| **Web & HTTP** | `web_search`, `web_fetch`, `http` |","| **Present & Visualize** | `present`, `signal`, `session_digest` |","| **Sandbox & Process** | `process`, `watch`, `workset`, `lane`, `queue`, `restore`, `delegate` |","| **Utilities** | `encode`, `regex_test`, `measure`, `changelog`, `schema_validate`, `env`, `time` |","| **Browser** | `browser` |",``,`## Important: Prefer AI Kit Tools Over Generic Shell Commands`,``,`When working in this project, use AI Kit MCP tools instead of generic alternatives:`,``,`| Instead of | Use AI Kit Tool | Why |`,`|-----------|----------------|-----|`,"| `grep` / `rg` | `mcp_aikit_search` or `mcp_aikit_find` | Hybrid search (vector + keyword + BM25) across all indexed content |","| `read_file` for understanding | `mcp_aikit_file_summary` | T1=structure, T2=structure+content — 10x fewer tokens than raw file reads |","| `cd` + `ls` | `mcp_aikit_analyze` | Structural analysis with tree views |","| Running tests in terminal | `mcp_aikit_test_run` | Structured test output — no shell needed |","| `tsc` / `biome` in terminal | `mcp_aikit_check` | Typecheck + lint combined |","| Web search | `mcp_aikit_web_search` | Fans out to multiple keyless providers |",``,`## Agents`,``,t,``,`## Agent Instructions`,``,u.join(`
 `),``,`## Prompts`,``,s,``,f,``,`## Session Protocol`,``,c(n),``].join(`
 `)}function _(e,t,n){let r=h(t),i=u(t.skills),a=e===`Orchestrator`?f:p,o=[n,...r,t.bodyAddendum,i,a].filter(Boolean).join(`
 

package/scaffold/dist/definitions/agents.mjs

@@ -24,6 +24,6 @@ ${l}
 ${e(a)}
 
 ${o}
-${s}`}}const i={Orchestrator:{title:`The Master Conductor`,description:`Master conductor that orchestrates the full development lifecycle: Planning → Implementation → Review → Recovery → Commit`,argumentHint:null,toolRole:`orchestrator`,sharedBase:null,sharedProtocols:[`layered-knowledge-operating-policy`],category:`orchestration`,skills:[[`aikit`,`**Always** — AI Kit recall, flow status, search, and ctx ref reuse`],[`multi-agents-development`,`Before delegation — decomposition, dispatch envelope, review pipeline`],[`present`,`For plans, reviews, evidence maps, approvals, and non-tiny user output`],[`brainstorming`,`For design forks, trade-offs, or creative requirements`],[`requirements-clarity`,`For vague, large, or cross-team requirements before planning`],[`c4-architecture`,`For architecture diagrams, boundary questions, or structure docs`],[`adr-skill`,`For non-trivial technical decisions and ADR lifecycle`],[`docs`,`For docs-sync, durable docs, PRDs, tours, and architecture docs`],[`lesson-learned`,`After implementation/review work — persist reusable engineering lessons`],[`session-handoff`,`When context pressure rises or work must pause/resume`],[`repo-access`,`For private/self-hosted repo access failures`],[`browser-use`,`For browser auth, JS-rendered pages, visual verification, web automation`]]},Planner:{title:`The Strategic Architect`,description:`Autonomous planner that researches codebases and writes comprehensive TDD implementation plans`,compactRole:`TDD implementation plans`,argumentHint:null,toolRole:`planner`,sharedBase:`code-agent-base`,sharedProtocols:[`thinking-principles`,`planning-principles`,`layered-knowledge-operating-policy`],category:`orchestration`,skills:[[`aikit`,`**Always** — AI Kit reading plans, recall, and compressed context reuse`],[`multi-agents-development`,`For decomposition, dependency batches, and dispatch envelopes`],[`brainstorming`,`For new feature/behavior planning and design alternatives`],[`requirements-clarity`,`For vague or large requirements before planning`],[`present`,`For plan, dependency graph, risk matrix, and approval display`],[`c4-architecture`,`For architecture changes and C4 diagrams`],[`adr-skill`,`For non-trivial technical decisions and ADRs`],[`session-handoff`,`For context pressure or session end`],[`repo-access`,`For private or self-hosted repo access`],[`browser-use`,`For auth recovery or browser workflows`]]},Implementer:{title:`The Code Builder`,description:`Persistent implementation agent that writes code following TDD practices until all tasks are complete`,compactRole:`New features, wire up, build`,argumentHint:`Implementation task, feature, or phase from plan`,toolRole:`codeAgent`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`react`,`When implementing React components, hooks, or pages`],[`lesson-learned`,`After completing non-obvious implementation work`]]},Frontend:{title:`The UI Specialist`,description:`UI/UX specialist for React, styling, responsive design, and frontend implementation`,compactRole:`UI/UX, React, styling, responsive`,argumentHint:`UI component, styling task, or frontend feature`,toolRole:`codeAgent`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`react`,`When building React components — hooks, patterns, Server Components`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`frontend-design`,`When implementing UI/UX — design systems, accessibility, responsive patterns`],[`browser-use`,`When visual/browser verification is needed`],[`lesson-learned`,`After completing non-obvious frontend implementation work`]]},Refactor:{title:`The Code Sculptor`,description:`Code refactoring specialist that improves structure, readability, and maintainability`,compactRole:`Cleanup, simplify, DRY, extract`,argumentHint:`Code, component, or pattern to refactor`,toolRole:`refactor`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When refactoring TypeScript code — type patterns, generics, utility types`],[`lesson-learned`,`After completing refactor — extract principles from before/after diff`]]},Debugger:{title:`The Problem Solver`,description:`Expert debugger that diagnoses issues, traces errors, and provides solutions using AI Kit traces and compressed context before raw file reads`,compactRole:`Bug diagnosis, error tracing`,argumentHint:`Error message, stack trace, or description of issue`,toolRole:`debugger`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`diagnostics`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`browser-use`,`For browser/UI reproduction loops and JS-rendered failures`],[`repo-access`,`When debugging depends on private or enterprise repo access`],[`lesson-learned`,`After a non-obvious root cause or fix`]]},Security:{title:`The Vulnerability Hunter`,description:`Security specialist that analyzes code for vulnerabilities and compliance`,compactRole:`Vulnerability analysis, auth hardening`,argumentHint:`Code, feature, or component to security review`,toolRole:`security`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`diagnostics`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When reviewing code — security patterns, type safety`],[`repo-access`,`When security review requires private/enterprise repo access`],[`browser-use`,`When reviewing browser auth, sessions, cookies, or web security flows`]]},Documenter:{title:`The Knowledge Keeper`,description:`Documentation specialist that creates and maintains comprehensive project documentation`,compactRole:`Project documentation`,argumentHint:`Component, API, feature, or area to document`,toolRole:`documenter`,sharedBase:`code-agent-base`,sharedProtocols:[`thinking-principles`,`documentation-principles`,`layered-knowledge-operating-policy`],category:`documentation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`docs`,`When creating or updating project documentation — docs/ convention, architecture blueprints, Diátaxis framework`],[`present`,`When presenting documentation previews or architecture visuals to the user`],[`c4-architecture`,`When documenting architecture, containers, components, or deployment`],[`adr-skill`,`When docs involve technical decisions or ADR updates`],[`typescript`,`When documenting TypeScript APIs, public types, or generated docs`],[`session-handoff`,`When docs work spans sessions or context pressure rises`]]},Explorer:{title:`The Rapid Scout`,description:`Rapid codebase exploration to find files, usages, dependencies, and structural context`,compactRole:`Rapid codebase navigation`,argumentHint:`Find files, usages, and context related to: {topic or goal}`,toolRole:`explorer`,sharedBase:null,sharedProtocols:[`thinking-principles`,`layered-knowledge-operating-policy`],category:`exploration`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`]]},Researcher:{title:`The Context Gatherer`,description:`Deep analysis, architecture review, and multi-model decision protocol participant`,compactRole:`Multi-model deep research`,argumentHint:`Research question, problem statement, or subsystem to investigate`,toolRole:`researcher`,sharedBase:`researcher-base`,sharedProtocols:[`thinking-principles`,`layered-knowledge-operating-policy`],category:`research`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`lesson-learned`,`When analyzing past changes to extract engineering principles`],[`c4-architecture`,`When researching system architecture — produce C4 diagrams`],[`adr-skill`,`When the research involves a technical decision — draft an ADR`],[`repo-access`,`When research needs private or enterprise repository access`],[`browser-use`,`When web research needs login, JS rendering, or browser automation`]],variants:{Alpha:n({description:`Primary deep research agent — also serves as default Researcher`,lensName:`Contrarian`,lensDescription:`deep research`,lensPrompt:`actively look for flaws, fatal assumptions, and hidden risks in every approach. The best ideas survive adversarial pressure.`,identityIntro:`, the primary deep research agent. During multi-model decision sessions, you provide deep reasoning and nuanced system design.`,requiredOutputSection:`Depth Analysis`,requiredOutputItems:[`Deep-dive into ONE chosen subsystem (most structurally central to the question)`,`Full evidence chain: file:line citations for every structural claim`,"At least 2 `compact`/`file_summary` extracts woven into the narrative"],focusAreas:[`For every proposed approach, actively seek the fatal flaw or hidden assumption`,`Ask: "Under what conditions does this approach fail catastrophically?"`,`Prefer uncomfortable truths over comfortable consensus`],variantSummary:`You are the DEFAULT researcher. When the Orchestrator needs breadth + depth, they
+${s}`}}const i={Orchestrator:{title:`The Master Conductor`,description:`Master conductor that orchestrates the full development lifecycle: Planning → Implementation → Review → Recovery → Commit`,argumentHint:null,toolRole:`orchestrator`,sharedBase:null,sharedProtocols:[`layered-knowledge-operating-policy`],category:`orchestration`,skills:[[`aikit`,`**Always** — AI Kit recall, flow status, search, and ctx ref reuse`],[`multi-agents-development`,`Before delegation — decomposition, dispatch envelope, review pipeline`],[`present`,`For plans, reviews, evidence maps, approvals, and non-tiny user output`],[`brainstorming`,`For design forks, trade-offs, or creative requirements`],[`requirements-clarity`,`For vague, large, or cross-team requirements before planning`],[`c4-architecture`,`For architecture diagrams, boundary questions, or structure docs`],[`adr-skill`,`For non-trivial technical decisions and ADR lifecycle`],[`docs`,`For docs-sync, durable docs, PRDs, tours, and architecture docs`],[`lesson-learned`,`After implementation/review work — persist reusable engineering lessons`],[`session-handoff`,`When context pressure rises or work must pause/resume`],[`repo-access`,`For private/self-hosted repo access failures`],[`browser-use`,`For browser auth, JS-rendered pages, visual verification, web automation`]],subagentConstraints:["Do NOT use the `present` tool — return all findings as structured text.","Do NOT call `get_changed_files` — it returns ALL uncommitted diffs (100K+ tokens). Use `git diff <file>` if needed.",`No flow advancement. Only Orchestrator advances the flow.`,"Return status: `DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED`. ≤200 words for normal status; full detail only if BLOCKED.",`Stay inside assigned files and boundary. Do not modify files outside scope.`]},Planner:{title:`The Strategic Architect`,description:`Autonomous planner that researches codebases and writes comprehensive TDD implementation plans`,compactRole:`TDD implementation plans`,argumentHint:null,toolRole:`planner`,sharedBase:`code-agent-base`,sharedProtocols:[`thinking-principles`,`planning-principles`,`layered-knowledge-operating-policy`],category:`orchestration`,skills:[[`aikit`,`**Always** — AI Kit reading plans, recall, and compressed context reuse`],[`multi-agents-development`,`For decomposition, dependency batches, and dispatch envelopes`],[`brainstorming`,`For new feature/behavior planning and design alternatives`],[`requirements-clarity`,`For vague or large requirements before planning`],[`present`,`For plan, dependency graph, risk matrix, and approval display`],[`c4-architecture`,`For architecture changes and C4 diagrams`],[`adr-skill`,`For non-trivial technical decisions and ADRs`],[`session-handoff`,`For context pressure or session end`],[`repo-access`,`For private or self-hosted repo access`],[`browser-use`,`For auth recovery or browser workflows`]]},Implementer:{title:`The Code Builder`,description:`Persistent implementation agent that writes code following TDD practices until all tasks are complete`,compactRole:`New features, wire up, build`,argumentHint:`Implementation task, feature, or phase from plan`,toolRole:`codeAgent`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`react`,`When implementing React components, hooks, or pages`],[`lesson-learned`,`After completing non-obvious implementation work`]]},Frontend:{title:`The UI Specialist`,description:`UI/UX specialist for React, styling, responsive design, and frontend implementation`,compactRole:`UI/UX, React, styling, responsive`,argumentHint:`UI component, styling task, or frontend feature`,toolRole:`codeAgent`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`react`,`When building React components — hooks, patterns, Server Components`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`frontend-design`,`When implementing UI/UX — design systems, accessibility, responsive patterns`],[`browser-use`,`When visual/browser verification is needed`],[`lesson-learned`,`After completing non-obvious frontend implementation work`]]},Refactor:{title:`The Code Sculptor`,description:`Code refactoring specialist that improves structure, readability, and maintainability`,compactRole:`Cleanup, simplify, DRY, extract`,argumentHint:`Code, component, or pattern to refactor`,toolRole:`refactor`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`implementation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When refactoring TypeScript code — type patterns, generics, utility types`],[`lesson-learned`,`After completing refactor — extract principles from before/after diff`]]},Debugger:{title:`The Problem Solver`,description:`Expert debugger that diagnoses issues, traces errors, and provides solutions using AI Kit traces and compressed context before raw file reads`,compactRole:`Bug diagnosis, error tracing`,argumentHint:`Error message, stack trace, or description of issue`,toolRole:`debugger`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`diagnostics`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When writing TypeScript code — type patterns, generics, utility types`],[`browser-use`,`For browser/UI reproduction loops and JS-rendered failures`],[`repo-access`,`When debugging depends on private or enterprise repo access`],[`lesson-learned`,`After a non-obvious root cause or fix`]]},Security:{title:`The Vulnerability Hunter`,description:`Security specialist that analyzes code for vulnerabilities and compliance`,compactRole:`Vulnerability analysis, auth hardening`,argumentHint:`Code, feature, or component to security review`,toolRole:`security`,sharedBase:`code-agent-base`,sharedProtocols:[`engineering-principles`,`layered-knowledge-operating-policy`],category:`diagnostics`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When reviewing code — security patterns, type safety`],[`repo-access`,`When security review requires private/enterprise repo access`],[`browser-use`,`When reviewing browser auth, sessions, cookies, or web security flows`]]},Documenter:{title:`The Knowledge Keeper`,description:`Documentation specialist that creates and maintains comprehensive project documentation`,compactRole:`Project documentation`,argumentHint:`Component, API, feature, or area to document`,toolRole:`documenter`,sharedBase:`code-agent-base`,sharedProtocols:[`thinking-principles`,`documentation-principles`,`layered-knowledge-operating-policy`],category:`documentation`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`docs`,`When creating or updating project documentation — docs/ convention, architecture blueprints, Diátaxis framework`],[`present`,`When presenting documentation previews or architecture visuals to the user`],[`c4-architecture`,`When documenting architecture, containers, components, or deployment`],[`adr-skill`,`When docs involve technical decisions or ADR updates`],[`typescript`,`When documenting TypeScript APIs, public types, or generated docs`],[`session-handoff`,`When docs work spans sessions or context pressure rises`]]},Explorer:{title:`The Rapid Scout`,description:`Rapid codebase exploration to find files, usages, dependencies, and structural context`,compactRole:`Rapid codebase navigation`,argumentHint:`Find files, usages, and context related to: {topic or goal}`,toolRole:`explorer`,sharedBase:null,sharedProtocols:[`thinking-principles`,`layered-knowledge-operating-policy`],category:`exploration`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`]]},Researcher:{title:`The Context Gatherer`,description:`Deep analysis, architecture review, and multi-model decision protocol participant`,compactRole:`Multi-model deep research`,argumentHint:`Research question, problem statement, or subsystem to investigate`,toolRole:`researcher`,sharedBase:`researcher-base`,sharedProtocols:[`thinking-principles`,`layered-knowledge-operating-policy`],category:`research`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`lesson-learned`,`When analyzing past changes to extract engineering principles`],[`c4-architecture`,`When researching system architecture — produce C4 diagrams`],[`adr-skill`,`When the research involves a technical decision — draft an ADR`],[`repo-access`,`When research needs private or enterprise repository access`],[`browser-use`,`When web research needs login, JS rendering, or browser automation`]],variants:{Alpha:n({description:`Primary deep research agent — also serves as default Researcher`,lensName:`Contrarian`,lensDescription:`deep research`,lensPrompt:`actively look for flaws, fatal assumptions, and hidden risks in every approach. The best ideas survive adversarial pressure.`,identityIntro:`, the primary deep research agent. During multi-model decision sessions, you provide deep reasoning and nuanced system design.`,requiredOutputSection:`Depth Analysis`,requiredOutputItems:[`Deep-dive into ONE chosen subsystem (most structurally central to the question)`,`Full evidence chain: file:line citations for every structural claim`,"At least 2 `file_summary` extracts woven into the narrative"],focusAreas:[`For every proposed approach, actively seek the fatal flaw or hidden assumption`,`Ask: "Under what conditions does this approach fail catastrophically?"`,`Prefer uncomfortable truths over comfortable consensus`],variantSummary:`You are the DEFAULT researcher. When the Orchestrator needs breadth + depth, they
 dispatch you alone. Your lens: thorough, evidence-first, exhaustive + contrarian.`}),Beta:n({description:`Research variant — pragmatic analysis with focus on trade-offs and edge cases`,lensName:`First Principles`,lensDescription:`pragmatic analysis`,lensPrompt:`strip away assumptions, decompose to ground truths, and rebuild reasoning from scratch.`,identityIntro:`, a variant of the Researcher agent optimized for **pragmatic analysis**. Focus on trade-offs, edge cases, and practical constraints. Challenge assumptions and highlight risks the primary researcher may overlook.`,requiredOutputSection:`Failure Modes & Counter-Evidence`,requiredOutputItems:[`At least 3 adversarial claims challenging your own primary finding`,`For each counter-claim: the condition under which it would be TRUE, and the
   evidence (file:line or search receipt) that currently falsifies it`,"Any unresolved counter-evidence flagged as `⚠ UNRESOLVED`"],focusAreas:[`Strip every assumption: "Is this truly required, or just inherited convention?"`,`Decompose to ground truths, then rebuild the reasoning from scratch`,`If the current approach exists only because "that's how it's always been done", flag it`],variantSummary:"Your lens: pragmatic skepticism + first principles. Mark competing claims as `A` (Assumed)\nby default; challenge before promoting to `V`."}),Gamma:n({description:`Research variant — broad pattern matching across domains and technologies`,lensName:`Expansionist`,lensDescription:`cross-domain pattern matching`,lensPrompt:`look for the bigger opportunity, find what's undervalued, and identify patterns others dismiss.`,identityIntro:`, a variant of the Researcher agent optimized for **cross-domain pattern matching**. Draw connections from other domains, frameworks, and industries. Bring breadth where Alpha brings depth.`,requiredOutputSection:`Cross-Domain Analogies`,requiredOutputItems:[`At least 2 patterns from other tools/frameworks/domains that apply to the question`,"For each: the external source (cite via `web_search` or `web_fetch` receipt) and\n  how it maps to our codebase",`One "missing pattern we should adopt" recommendation`],focusAreas:[`Ask: "What's the bigger opportunity everyone else is ignoring?"`,`Seek undervalued approaches and non-obvious connections across domains`,`Challenge narrow framing: "Is this really just an X problem, or is it also a Y problem?"`],variantSummary:"Your lens: cross-domain pattern matching + expansionist. Weight `web_search` + `web_fetch`\nhigher than peers. Assume the LLM's training data is stale — verify with fresh searches."}),Delta:n({description:`Research variant — implementation feasibility and performance implications`,lensName:`Executor`,lensDescription:`implementation feasibility`,lensPrompt:`focus on what can actually be built, the fastest path to value, and real-world constraints.`,identityIntro:`, a variant of the Researcher agent optimized for **implementation feasibility**. Focus on performance implications, scaling concerns, and concrete implementation paths. Ground theoretical proposals in practical reality.`,requiredOutputSection:`Implementation Cost & Feasibility`,requiredOutputItems:["Complexity snapshot: you MUST call `measure({ path })` on any file ≥ 50 LOC in the\n  target subsystem at least once and quote the `cognitiveComplexity` result","Blast radius estimate: `blast_radius({ changed_files })` on the proposed edits",`Time/risk table: | Change | Lines | Risk | Effort |`,`Feasibility verdict: SAFE / RISKY / INFEASIBLE with one-line justification`],focusAreas:[`Ask: "Can this actually be built? What's the fastest path to a working version?"`,`Ground every proposal in concrete effort: lines of code, files changed, risk`,`Reject elegant theory that can't survive contact with the codebase`],variantSummary:'Your lens: implementation feasibility + executor. Prefer `measure` + `blast_radius` +\n`analyze({ items: [{aspect: "patterns", ...}] })` over abstract reasoning.'})}},"Code-Reviewer":{title:`The Quality Guardian`,description:`Code review specialist analyzing code for quality, security, performance, and maintainability`,compactRole:`Dual-perspective code review`,argumentHint:`File path, PR, or code to review`,toolRole:`reviewer`,sharedBase:`code-reviewer-base`,sharedProtocols:[`thinking-principles`,`review-principles`,`layered-knowledge-operating-policy`],category:`review`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`typescript`,`When reviewing TypeScript code — type patterns, best practices`],[`lesson-learned`,`When review exposes a reusable engineering lesson`]],variants:{Alpha:r({roleName:`Code-Reviewer`,description:`Primary code reviewer`,lensName:`Compliance & Red-Team`,lensDescription:`compliance and red-teaming`,lensPrompt:`you hunt for correctness bugs, security holes, and contract violations that will break in production.`,identityIntro:`, the primary Code-Reviewer agent.`,focusAreas:[`**Correctness** — Logic errors, race conditions, null/undefined paths, off-by-one`,`**Security** — OWASP Top 10, input validation, secrets, injection vectors`,`**Contract compliance** — Does this honor its type signatures, API contracts, and invariants?`,`**Error handling** — What happens on the unhappy path? Missing try/catch, swallowed errors`],instinct:`Your instinct: "How does this break?" Think like an attacker and a pessimist.`,closing:`When in doubt, flag it — false positives are cheaper than missed bugs in production.`}),Beta:r({roleName:`Code-Reviewer`,description:`Code reviewer variant — different LLM perspective for dual review`,lensName:`Quality & Engineering Excellence`,lensDescription:`quality and engineering excellence`,lensPrompt:`you focus on maintainability, performance, testing, and whether the code will age well.`,identityIntro:`, the secondary Code-Reviewer agent.`,focusAreas:[`**Maintainability** — Naming clarity, single responsibility, cognitive complexity, DRY`,`**Performance** — N+1 queries, unnecessary allocations, missing caching, O(n²) where O(n) suffices`,`**Testing** — Coverage for new/changed logic, edge cases, test readability`,`**Patterns** — Consistency with existing codebase conventions, idiomatic usage`],instinct:`Your instinct: "Will a new team member understand this in 6 months?" Think like a mentor.`,closing:`Prefer actionable suggestions over vague concerns. Show the better version when possible.`})}},"Architect-Reviewer":{title:`The Structural Guardian`,description:`Reviews architecture for pattern adherence, SOLID compliance, dependency direction, and structural integrity`,compactRole:`Architecture review`,argumentHint:`Files, PR, or subsystem to architecture-review`,toolRole:`reviewer`,sharedBase:`architect-reviewer-base`,sharedProtocols:[`thinking-principles`,`review-principles`,`layered-knowledge-operating-policy`],category:`review`,skills:[[`aikit`,`**Always** — AI Kit tool signatures, search, analysis`],[`c4-architecture`,`When reviewing architectural diagrams or boundary changes`],[`adr-skill`,`When the review involves architecture decisions — reference or create ADRs`],[`docs`,`When architecture review should update durable documentation`]],extraBody:`You are **not** the Code-Reviewer agent. Code-Reviewer handles correctness, testing, security, and code quality. You handle the big picture: service boundaries, dependency direction, pattern adherence, and structural health.`,variants:{Alpha:r({roleName:`Architect-Reviewer`,description:`Primary architecture reviewer`,lensName:`Structural Prosecutor`,lensDescription:`structural prosecution`,lensPrompt:`you challenge architectural choices, find boundary violations, and test whether the design survives growth.`,identityIntro:`, the primary Architect-Reviewer agent.`,focusHeading:`Your primary focus areas:`,focusAreas:[`**Boundary violations** — Does this cross package/module boundaries it shouldn't?`,`**Dependency direction** — Are dependencies flowing inward? Any layer leakage?`,`**Hidden coupling** — Shared mutable state, implicit contracts, temporal coupling`,`**Scalability stress** — What breaks at 10x load, 10x data, 10x features?`],instinct:`Your instinct: "This design will fail when..." Challenge every architectural assumption.`,closing:`If a boundary is crossed, require justification or block.`}),Beta:r({roleName:`Architect-Reviewer`,description:`Architecture reviewer variant — different LLM perspective for dual review`,lensName:`Pragmatic Defense`,lensDescription:`pragmatic defense`,lensPrompt:`you evaluate whether the architecture is proportional to the problem, and defend reasonable trade-offs.`,identityIntro:`, the secondary Architect-Reviewer agent.`,focusHeading:`Your primary focus areas:`,focusAreas:[`**Proportionality** — Is the architecture proportional to the problem? Over-engineering is a defect.`,`**Trade-off validity** — Are the trade-offs explicitly acknowledged and reasonable?`,`**Migration path** — Can this evolve without a rewrite? Is there a clear upgrade path?`,`**Team ergonomics** — Can the team actually maintain this? Does it match their skills?`],instinct:`Your instinct: "Is this the simplest architecture that solves the actual problem?"`,closing:`Push back on unnecessary complexity. Defend working solutions against premature abstraction.`})}}};export{i as AGENTS};

package/scaffold/dist/definitions/bodies.mjs

@@ -1,4 +1,6 @@
-import{postTaskLesson as e,preTaskKnowledgeRecall as t,renderLayeredKnowledgeOperatingPolicyV1 as n}from"./protocols.mjs";const r=()=>``,i={Orchestrator:e=>`You orchestrate full lifecycle: planning -> implementation -> review -> recovery -> commit. Own contract: what, order, owner. No source-code edits; delegate all implementation.
+import{AGENTS as e}from"./agents.mjs";import{postTaskLesson as t,preTaskKnowledgeRecall as n,renderLayeredKnowledgeOperatingPolicyV1 as r}from"./protocols.mjs";const i=()=>``;function a(){let t=e.Orchestrator?.subagentConstraints??[];return t.length===0?`*(none configured)*`:`**Constraints** — auto-appended to EVERY subagent dispatch:
+${t.map((e,t)=>`   ${t+1}. ${e}`).join(`
+`)}`}const o={Orchestrator:e=>`You orchestrate full lifecycle: planning -> implementation -> review -> recovery -> commit. Own contract: what, order, owner. No source-code edits; delegate all implementation.
 
 ## Prime Contract
 1. Plan work.
@@ -70,16 +72,15 @@ Every \`runSubagent\` prompt includes all of:
 
 1. **Agent + Goal** — exact specialist name, testable acceptance criteria.
 2. **Files + Boundary** — target files, do-not-touch list.
- 3. **Arch Context** — Pre-compress with AI Kit tools before including in prompt. pick by token budget: efficient → \`stratum_card\`, normal → \`compact\`, full → \`digest\`. Default efficient. **Never pass raw file contents — always compress first.** This eliminates subagent need for \`read_file\`.
+ 3. **Arch Context** — Pre-compress with AI Kit tools before including in prompt. pick by token budget: efficient → \`file_summary\` (T1=structure, T2=content), full → \`digest\`. Default efficient. **Never pass raw file contents — always compress first.** This eliminates subagent need for \`read_file\`.
 4. **Prior Knowledge** — \`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<2-3 keywords>", minConfidence: 70 })\` + \`search({ query: "<task area>", category: "conventions", limit: 3 })\`. Include high-confidence results. Skip for Floor.
 5. **Artifacts Path** — active flow's run dir / artifacts path from \`flow({ action: 'status' })\`.
 6. **FORGE** — tier, task_id, evidence requirements. Reviewers add CRITICAL/HIGH claims into your task_id; never create their own.
 7. **Flow Context** — "Call \`knowledge({ action: 'withdraw', scope: 'flow', profile: '<role>', budget: 6000 })\` as your FIRST action. Reuse withdrawn refs and L0 card refs before broad retrieval. Do NOT independently reload workspace-core or architecture cards when dispatch already carries applicable refs."
-8. **Constraints** — skills to load, no \`present\`, no flow advance, no broad diff tools.
-9. **Self-Review** — checklist before declaring status: scope respected? tests pass? conventions followed?
-10. **No \`present\`** — "Do NOT use the \`present\` tool — return all findings as structured text."
-11. **No \`get_changed_files\`** — "Do NOT call \`get_changed_files\` — it returns ALL uncommitted diffs (100K+ tokens). Use \`git diff <file>\` if needed."
-12. **Return contract** — \`DONE\` | \`DONE_WITH_CONCERNS\` | \`NEEDS_CONTEXT\` | \`BLOCKED\`. ≤200 words: status, files, decisions. Full detail only if BLOCKED.
+ 8. ${a().replace(/\n/g,`
+    `)}
+ 9. **Self-Review** — checklist before declaring status: scope respected? tests pass? conventions followed?
+ 10. **Return contract** — \`DONE\` | \`DONE_WITH_CONCERNS\` | \`NEEDS_CONTEXT\` | \`BLOCKED\`. ≤200 words: status, files, decisions. Full detail only if BLOCKED.
 
 Always pass \`agentName\`. Missing/empty is a dispatch bug.
 
@@ -90,16 +91,16 @@ Always pass \`agentName\`. Missing/empty is a dispatch bug.
 | Need | Use |
 |------|-----|
 | L0 session briefing | \`status({ includePrelude: true })\` — workspace-core available after \`onboard()\`. Flow card via flow context. |
-| Assess scope before dispatch | \`file_summary\`, \`compact\`, \`stratum_card\` |
-| Pre-populate subagent with context | \`stratum_card\` (efficient), \`compact\` (normal), \`digest\` (full) |
+| Assess scope before dispatch | \`file_summary\` |
+| Pre-populate subagent with context | \`file_summary\` |
 | L1 flow withdrawal | \`knowledge({ action: 'withdraw', scope: 'flow', profile: '<role>', budget: 6000 })\` — reuse before broad retrieval |
 | L2 canonical knowledge | \`search()\` or \`knowledge({ action: 'read' })\` — on-demand only |
 | L3 evidence/provenance | \`search({ query })\` + \`knowledge({ action: 'lesson' })\` — focused retrieval only |
-| Understand error during emergency | \`compact({ path, query })\` — never raw-read |
+| Understand error during emergency | \`file_summary({ files, tier: 'T2', query })\` — never raw-read |
 | Between phases: compress state | \`session_digest({ persist: true, focus: "<topic>" })\` |
 | After batch: persist summary | \`knowledge({ action: 'remember', scope: 'flow', ... })\` |
 
-${n({audience:`agent`})}
+${r({audience:`agent`})}
 
 \`read_file\` is ONLY for exact edit lines. Or when diagnosing an emergency with \`git diff --stat\` + \`check({})\`. No exceptions for planning or discovery.
 
@@ -127,7 +128,7 @@ Use web_fetch/http first. On auth failure, load repo-access; if exhausted, use A
 - reindex after structural changes; produce_knowledge for durable updates; remember non-trivial decisions.
 - L0 card maintenance: changed topics after flow completion schedule L0 card regeneration via \`briefing-card-compiler\`.
 - Flow-derived promotion: evidence-backed promotion candidates from final consolidation; confidence alone never promotes.
-- session_digest({ persist: true }).`,Planner:`${r()}
+- session_digest({ persist: true }).`,Planner:`${i()}
 
 > **Reminder:** Follow ## MANDATORY FIRST ACTION from your shared base protocol.
 
@@ -179,7 +180,7 @@ Use web_fetch/http first. On auth failure, load repo-access; if exhausted, use A
 **Open Questions** / **Risks**
 \`\`\`
 
-**🛑 MANDATORY STOP** — Wait for user approval before any implementation.`,Implementer:`${r()}
+**🛑 MANDATORY STOP** — Wait for user approval before any implementation.`,Implementer:`${i()}
 
 ## Implementation Protocol
 
@@ -202,12 +203,12 @@ Use web_fetch/http first. On auth failure, load repo-access; if exhausted, use A
 ## Pre-Edit Checklist
 
 1. **Understand consumers** — \`graph({action:'find_nodes', name_pattern:'<target>'})\` → \`graph({action:'neighbors', node_id, direction:'incoming'})\`
- 2. **Compress, don't raw-read (HARD RULE)** — If you catch yourself about to call \`read_file\`, stop. Use \`file_summary\` first, then \`compact({ items: [{path, query}] })\` or \`compact({ref, query?})\`. \`read_file\` is ONLY for exact line content before \`replace_string_in_file\` — never for exploration or understanding.
+ 2. **Compress, don't raw-read (HARD RULE)** — If you catch yourself about to call \`read_file\`, stop. Choose \`file_summary({ files, tier: 'T1', query })\` for structure-only, or \`file_summary({ files, tier: 'T2', query })\` for structure+content — one call, pick the right tier. \`read_file\` is ONLY for exact line content before \`replace_string_in_file\` — never for exploration or understanding.
 3. **Snapshot risky edits** — \`checkpoint({action:'save', label:'pre-<scope>'})\` before cross-cutting changes
 4. **Estimate blast radius** — run \`blast_radius\` before and after shared/public symbol changes
 5. **TDD when tests exist** — failing test first, then minimum code
 
-${t({intro:`Before starting implementation, recall relevant lessons and conventions **scoped to your specific task**:`,commands:[`// Extract 2-3 keywords from your assigned task`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<task keywords>", minConfidence: 70, limit: 3 })`,`search({ query: "<task area> convention", category: "conventions", limit: 3 })`],followUp:"**Rules:**\n- ALWAYS scope by topic — NEVER call `list-lessons` without `topic` param\n- ALWAYS limit results — `limit: 3` for search, `minConfidence: 70` for lessons\n- If recalled lessons apply → follow them, note which you followed in Status\n- If recalled lessons conflict → note the conflict in Status\n- Skip ONLY if task is pure config/formatting with zero logic"})}
+${n({intro:`Before starting implementation, recall relevant lessons and conventions **scoped to your specific task**:`,commands:[`// Extract 2-3 keywords from your assigned task`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<task keywords>", minConfidence: 70, limit: 3 })`,`search({ query: "<task area> convention", category: "conventions", limit: 3 })`],followUp:"**Rules:**\n- ALWAYS scope by topic — NEVER call `list-lessons` without `topic` param\n- ALWAYS limit results — `limit: 3` for search, `minConfidence: 70` for lessons\n- If recalled lessons apply → follow them, note which you followed in Status\n- If recalled lessons conflict → note the conflict in Status\n- Skip ONLY if task is pure config/formatting with zero logic"})}
 
 ## Post-Edit Checklist
 
@@ -215,7 +216,7 @@ ${t({intro:`Before starting implementation, recall relevant lessons and conventi
 2. \`test_run({})\`
 3. If Orchestrator passed a \`task_id\`: add verified claims to \`evidence_map\`; do not run gate
 
-${e()}
+${t()}
 
 ## Structured Output (MANDATORY)
 
@@ -237,7 +238,7 @@ Every implementation response MUST end with a structured status block:
 - Description of blocker
 \`\`\`
 
-`,Frontend:`${r()}
+`,Frontend:`${i()}
 
 ## Frontend Protocol
 
@@ -279,13 +280,13 @@ Every implementation response MUST end with a structured status block:
 8. Compare against supplied design tokens/Figma
 9. Fail fast on contrast < 4.5:1 or missing focus indicator
 
-If pre-flight cannot start the dev server, fall back to \`compact\` + expected visual behavior.
+If pre-flight cannot start the dev server, fall back to \`file_summary\` + expected visual behavior.
 
-${t({title:`Pattern Recall`,intro:`Before implementing UI work, check existing component patterns:`,commands:[`search({ query: "<component/feature area> pattern", category: "conventions", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<UI area>", minConfidence: 70, limit: 3 })`],followUp:`Follow discovered patterns for consistency. Note any patterns followed in Status.`})}
+${n({title:`Pattern Recall`,intro:`Before implementing UI work, check existing component patterns:`,commands:[`search({ query: "<component/feature area> pattern", category: "conventions", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<UI area>", minConfidence: 70, limit: 3 })`],followUp:`Follow discovered patterns for consistency. Note any patterns followed in Status.`})}
 
-${e()}
+${t()}
 
-`,Debugger:`${r()}
+`,Debugger:`${i()}
 
 ## Debugging Protocol
 
@@ -354,11 +355,11 @@ For tool-invocation issues:
 3. Correlate it across replay entries, in-memory telemetry, and server middleware context
 4. Search replay logs for that UUID to reconstruct the call lifecycle
 
-${t({title:`Error Pattern Recall`,intro:`Before diagnosing, search for prior solutions to similar errors:`,commands:[`// Use error message keywords or failing module name`,`search({ query: "<error keywords or module name>", category: "context", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<error area>", minConfidence: 60, limit: 3 })`],followUp:`If a prior fix exists for the same pattern → try it first before deep investigation.`})}
+${n({title:`Error Pattern Recall`,intro:`Before diagnosing, search for prior solutions to similar errors:`,commands:[`// Use error message keywords or failing module name`,`search({ query: "<error keywords or module name>", category: "context", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<error area>", minConfidence: 60, limit: 3 })`],followUp:`If a prior fix exists for the same pattern → try it first before deep investigation.`})}
 
-${e()}
+${t()}
 
-`,Refactor:`${r()}
+`,Refactor:`${i()}
 
 ## Refactoring Protocol
 
@@ -406,11 +407,11 @@ For multi-approach uncertainty (A vs B):
 - Delegate to \`Researcher-Delta\` for read-only feasibility work
 - Apply the winning approach under the checkpoint protocol
 
-${t({title:`Convention Recall`,intro:`Before refactoring, check existing conventions for the target area:`,commands:[`search({ query: "<module/pattern being refactored> convention", category: "conventions", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<refactor area>", minConfidence: 70, limit: 3 })`],followUp:`Follow discovered conventions. Do NOT introduce patterns that contradict established conventions without surfacing the conflict.`})}
+${n({title:`Convention Recall`,intro:`Before refactoring, check existing conventions for the target area:`,commands:[`search({ query: "<module/pattern being refactored> convention", category: "conventions", limit: 3 })`,`knowledge({ action: "lesson", subAction: "list-lessons", topic: "<refactor area>", minConfidence: 70, limit: 3 })`],followUp:`Follow discovered conventions. Do NOT introduce patterns that contradict established conventions without surfacing the conflict.`})}
 
-${e()}
+${t()}
 
-`,Security:`${r()}
+`,Security:`${i()}
 
 > **Reminder:** Follow ## MANDATORY FIRST ACTION from your shared base protocol.
 
@@ -457,14 +458,14 @@ After shared bootstrap, run \`search({ query: "security vulnerabilities conventi
 1. **[SEVERITY]** Title — Description, file:line, remediation
 \`\`\`
 
-`,Documenter:`${r()}
+`,Documenter:`${i()}
 
 > **Reminder:** Follow ## MANDATORY FIRST ACTION from your shared base protocol.
 
 ## Documentation Protocol
 
 1. **AI Kit Recall** — \`search({ query: "documentation <area>" })\` + \`knowledge({ action: "list" })\`
-2. **Analyze** — \`analyze({ items: [{aspect: "structure", ...}] })\`, \`analyze({ items: [{aspect: "entry_points", ...}] })\`, \`file_summary\`
+2. **Analyze** — \`analyze({ items: [{aspect: "structure", ...}] })\`, \`analyze({ items: [{aspect: "entry_points", ...}] })\`, \`file_summary({ files, tier: 'T1' })\`
 3. **Draft** — write docs following project conventions
 4. **Cross-reference** — link related docs, keep consistency
 5. **Persist** — \`knowledge({ action: "remember", title: "Docs: <standard>", content: "<details>", category: "conventions" })\` for new standards
@@ -510,7 +511,7 @@ After shared bootstrap, run \`search({ query: "security vulnerabilities conventi
 
 **Escape hatch** (Orwell Rule 6): Break any style rule sooner than write something unclear or unnatural.
 
-`,Explorer:`${r()}
+`,Explorer:`${i()}
 
 ## MANDATORY FIRST ACTION
 
@@ -540,8 +541,8 @@ When dispatched inside an active flow:
 
 1. **AI Kit Recall** — \`search\` for existing analysis
 2. **Discover** — \`find\`, \`symbol\`, \`scope_map\`
-3. **Analyze** — \`analyze\`, \`file_summary\`
-4. **Compress** — \`compact\`, \`digest\`, \`stratum_card\`
+3. **Analyze** — \`analyze\`, \`file_summary({ files, tier: 'T1' })\`
+4. **Compress** — \`file_summary\`, \`digest\`
 5. **Map** — files, exports, deps, call chains
 6. **Report** — structured findings with file paths and observations
 
@@ -552,7 +553,7 @@ When dispatched inside an active flow:
 | Find files for a feature | \`find\`, \`scope_map\` |
 | Map a symbol's usage | \`symbol\`, \`trace\` |
 | Map module relationships | \`graph({ action: 'neighbors' })\` — import/export edges across packages |
-| Understand a package | \`analyze({ items: [{aspect: "structure", ...}] })\`, \`analyze({ items: [{aspect: "dependencies", ...}] })\`, \`file_summary\` |
+| Understand a package | \`analyze({ items: [{aspect: "structure", ...}] })\`, \`analyze({ items: [{aspect: "dependencies", ...}] })\`, \`file_summary({ files, tier: 'T1' })\` |
 | Check impact of a change | \`blast_radius\` |
 
 ## Output Format
@@ -574,4 +575,4 @@ When dispatched inside an active flow:
 
 - **Speed over depth** — provide a useful map quickly
 - **Read-only** — never create, edit, or delete files
-- **Structured output** — always return findings in the format above`};export{i as AGENT_BODIES};
+- **Structured output** — always return findings in the format above`};export{o as AGENT_BODIES};

package/scaffold/dist/definitions/flows.mjs

@@ -1,5 +1,5 @@
 const e=e=>!e||e.length===0?``:`**Skills for this step:** ${e.map(e=>`\`${e}\``).join(`, `)}.
-Load them when their preconditions are met.`,t={design:{contextProfile:`researcher`,l0CardTypes:[`workspace-core`,`architecture`],l1Fields:[`objective`,`acceptanceCriteria`,`scope`,`exclusions`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`decisions`,`retrievedRefs`,`summary`],candidateLearnings:[`Architectural decisions with evidence`,`Scope boundary lessons`],handoffArtifact:`design-decisions.md`,handoffFields:[`decisions`,`scope`,`exclusions`,`retrievedRefs`]},spec:{contextProfile:`researcher`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`acceptanceCriteria`,`decisions`,`scope`],l2Refs:`required`,l3Evidence:`none`,updates:[`acceptanceCriteria`,`decisions`,`unresolvedClaims`],candidateLearnings:[`Requirement ambiguity lessons when evidenced`,`Contract boundary clarity`],handoffArtifact:`spec.md`,handoffFields:[`acceptanceCriteria`,`scope`,`decisions`]},plan:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`,`architecture`],l1Fields:[`acceptanceCriteria`,`scope`,`decisions`,`retrievedRefs`],l2Refs:`required`,l3Evidence:`none`,updates:[`decisions`,`artifacts`,`stepSummaries`],candidateLearnings:[`Planning pattern when reusable and evidenced`],handoffArtifact:`plan.md`,handoffFields:[`artifacts`,`decisions`]},task:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`],l1Fields:[`acceptanceCriteria`,`scope`,`decisions`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`artifacts`,`stepSummaries`],candidateLearnings:[],handoffArtifact:`tasks.md`,handoffFields:[`artifacts`,`stepSummaries`]},execute:{contextProfile:`implementer`,l0CardTypes:[],l1Fields:[`artifacts`,`scope`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`on-demand`,updates:[`artifacts`,`summaries`,`failures`,`successPatterns`,`verifiedClaims`,`assumedClaims`],candidateLearnings:[`Candidate only — no promotion`],handoffArtifact:`progress.md`,handoffFields:[`artifacts`,`summaries`,`failures`,`successPatterns`]},verify:{contextProfile:`reviewer`,l0CardTypes:[],l1Fields:[`acceptanceCriteria`,`artifacts`,`verifiedClaims`,`assumedClaims`,`unresolvedClaims`],l2Refs:`on-demand`,l3Evidence:`required`,updates:[`verifiedClaims`,`unresolvedClaims`,`verifiedFinalOutcome`],candidateLearnings:[`Confirm or reject candidates — no direct promotion`],handoffArtifact:`verify-report.md`,handoffFields:[`verifiedClaims`,`verifiedFinalOutcome`]},"basic-design":{contextProfile:`researcher`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`acceptanceCriteria`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`decisions`,`summary`],candidateLearnings:[],handoffArtifact:`design-decisions.md`,handoffFields:[`decisions`]},assess:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`scope`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`summary`,`retrievedRefs`],candidateLearnings:[],handoffArtifact:`assessment.md`,handoffFields:[`scope`,`retrievedRefs`]},"basic-implement":{contextProfile:`implementer`,l0CardTypes:[],l1Fields:[`scope`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`on-demand`,updates:[`artifacts`,`summaries`,`verifiedClaims`],candidateLearnings:[`Candidate only — no promotion`],handoffArtifact:`progress.md`,handoffFields:[`artifacts`,`summaries`]},"basic-verify":{contextProfile:`reviewer`,l0CardTypes:[],l1Fields:[`acceptanceCriteria`,`artifacts`,`verifiedClaims`],l2Refs:`none`,l3Evidence:`required`,updates:[`verifiedClaims`,`verifiedFinalOutcome`],candidateLearnings:[],handoffArtifact:`verify-report.md`,handoffFields:[`verifiedFinalOutcome`]},"docs-sync":{contextProfile:`documenter`,l0CardTypes:[],l1Fields:[`artifacts`,`stepSummaries`,`candidateLearnings`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[],candidateLearnings:[`L2 candidate mapping from durable doc changes`],handoffArtifact:``,handoffFields:[]},"lesson-learned":{contextProfile:`documenter`,l0CardTypes:[],l1Fields:[`failures`,`successPatterns`,`candidateLearnings`,`verifiedFinalOutcome`],l2Refs:`none`,l3Evidence:`on-demand`,updates:[],candidateLearnings:[`Evidence-backed candidate learnings into L1/L3`],handoffArtifact:``,handoffFields:[]}},n="### Dispatch Protocol\n- **Max 2 corrective retries** per task, then escalate.\n- Use `knowledge({ action: 'withdraw', scope: 'flow', profile: '<role>', budget: 6000 })` before dispatching.\n- Context: `stratum_card` for efficient, `compact` for focused, `digest` for multi-file synthesis.\n- Subagents: `DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED`. No `present`. No flow advance.",r='### Evidence Gate\nStandard/Critical: Use one stable `task_id` (from Design/Assessment).\n1. `evidence_map({ action: "create", task_id: "<slug>", tier: "<tier>" })` — create once.\n2. Add CRITICAL/HIGH claims during implementation and review.\n3. Orchestrator calls `evidence_map({ action: "gate", task_id: "<slug>" })` → YIELD/HOLD/HARD_BLOCK.\n4. HOLD → fix, re-gate (max 2 retries). HARD_BLOCK → escalate.',i={_epilogue:[{file:`steps/docs-sync/README.md`,content:`# Epilogue: Documentation Sync
+Load them when their preconditions are met.`,t={design:{contextProfile:`researcher`,l0CardTypes:[`workspace-core`,`architecture`],l1Fields:[`objective`,`acceptanceCriteria`,`scope`,`exclusions`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`decisions`,`retrievedRefs`,`summary`],candidateLearnings:[`Architectural decisions with evidence`,`Scope boundary lessons`],handoffArtifact:`design-decisions.md`,handoffFields:[`decisions`,`scope`,`exclusions`,`retrievedRefs`]},spec:{contextProfile:`researcher`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`acceptanceCriteria`,`decisions`,`scope`],l2Refs:`required`,l3Evidence:`none`,updates:[`acceptanceCriteria`,`decisions`,`unresolvedClaims`],candidateLearnings:[`Requirement ambiguity lessons when evidenced`,`Contract boundary clarity`],handoffArtifact:`spec.md`,handoffFields:[`acceptanceCriteria`,`scope`,`decisions`]},plan:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`,`architecture`],l1Fields:[`acceptanceCriteria`,`scope`,`decisions`,`retrievedRefs`],l2Refs:`required`,l3Evidence:`none`,updates:[`decisions`,`artifacts`,`stepSummaries`],candidateLearnings:[`Planning pattern when reusable and evidenced`],handoffArtifact:`plan.md`,handoffFields:[`artifacts`,`decisions`]},task:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`],l1Fields:[`acceptanceCriteria`,`scope`,`decisions`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`artifacts`,`stepSummaries`],candidateLearnings:[],handoffArtifact:`tasks.md`,handoffFields:[`artifacts`,`stepSummaries`]},execute:{contextProfile:`implementer`,l0CardTypes:[],l1Fields:[`artifacts`,`scope`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`on-demand`,updates:[`artifacts`,`summaries`,`failures`,`successPatterns`,`verifiedClaims`,`assumedClaims`],candidateLearnings:[`Candidate only — no promotion`],handoffArtifact:`progress.md`,handoffFields:[`artifacts`,`summaries`,`failures`,`successPatterns`]},verify:{contextProfile:`reviewer`,l0CardTypes:[],l1Fields:[`acceptanceCriteria`,`artifacts`,`verifiedClaims`,`assumedClaims`,`unresolvedClaims`],l2Refs:`on-demand`,l3Evidence:`required`,updates:[`verifiedClaims`,`unresolvedClaims`,`verifiedFinalOutcome`],candidateLearnings:[`Confirm or reject candidates — no direct promotion`],handoffArtifact:`verify-report.md`,handoffFields:[`verifiedClaims`,`verifiedFinalOutcome`]},"basic-design":{contextProfile:`researcher`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`acceptanceCriteria`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`decisions`,`summary`],candidateLearnings:[],handoffArtifact:`design-decisions.md`,handoffFields:[`decisions`]},assess:{contextProfile:`implementer`,l0CardTypes:[`workspace-core`],l1Fields:[`objective`,`scope`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[`summary`,`retrievedRefs`],candidateLearnings:[],handoffArtifact:`assessment.md`,handoffFields:[`scope`,`retrievedRefs`]},"basic-implement":{contextProfile:`implementer`,l0CardTypes:[],l1Fields:[`scope`,`retrievedRefs`],l2Refs:`on-demand`,l3Evidence:`on-demand`,updates:[`artifacts`,`summaries`,`verifiedClaims`],candidateLearnings:[`Candidate only — no promotion`],handoffArtifact:`progress.md`,handoffFields:[`artifacts`,`summaries`]},"basic-verify":{contextProfile:`reviewer`,l0CardTypes:[],l1Fields:[`acceptanceCriteria`,`artifacts`,`verifiedClaims`],l2Refs:`none`,l3Evidence:`required`,updates:[`verifiedClaims`,`verifiedFinalOutcome`],candidateLearnings:[],handoffArtifact:`verify-report.md`,handoffFields:[`verifiedFinalOutcome`]},"docs-sync":{contextProfile:`documenter`,l0CardTypes:[],l1Fields:[`artifacts`,`stepSummaries`,`candidateLearnings`],l2Refs:`on-demand`,l3Evidence:`none`,updates:[],candidateLearnings:[`L2 candidate mapping from durable doc changes`],handoffArtifact:``,handoffFields:[]},"lesson-learned":{contextProfile:`documenter`,l0CardTypes:[],l1Fields:[`failures`,`successPatterns`,`candidateLearnings`,`verifiedFinalOutcome`],l2Refs:`none`,l3Evidence:`on-demand`,updates:[],candidateLearnings:[`Evidence-backed candidate learnings into L1/L3`],handoffArtifact:``,handoffFields:[]}},n="### Dispatch Protocol\n- **Max 2 corrective retries** per task, then escalate.\n- Use `knowledge({ action: 'withdraw', scope: 'flow', profile: '<role>', budget: 6000 })` before dispatching.\n- Context: `file_summary` (T1=structure, T2=structure+content), `digest` for multi-file synthesis.\n- Subagents: `DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED`. No `present`. No flow advance.",r='### Evidence Gate\nStandard/Critical: Use one stable `task_id` (from Design/Assessment).\n1. `evidence_map({ action: "create", task_id: "<slug>", tier: "<tier>" })` — create once.\n2. Add CRITICAL/HIGH claims during implementation and review.\n3. Orchestrator calls `evidence_map({ action: "gate", task_id: "<slug>" })` → YIELD/HOLD/HARD_BLOCK.\n4. HOLD → fix, re-gate (max 2 retries). HARD_BLOCK → escalate.',i={_epilogue:[{file:`steps/docs-sync/README.md`,content:`# Epilogue: Documentation Sync
 
 > **This is a mandatory epilogue step.** Runs after every flow to keep project documentation synced with code changes.
 
@@ -86,13 +86,13 @@ Use the \`docs\` skill Architecture Blueprint sections as the template.
 When \`docs/\` already exists:
 
 \`\`\`
-compact({ items: [{path: "docs/architecture/overview.md", query: "section to update"}] })  # Read target section
+file_summary({ files: ["docs/architecture/overview.md"], tier: 'T2', query: "section to update" })  # Read target section
 blast_radius({ path: ".", files: ["<files>"] })                                # What's affected
 \`\`\`
 
 - **Don't rewrite** — update relevant sections only
 - **Don't duplicate** — reference code comments or READMEs when they already contain it
-- Use \`compact\` to read existing doc sections before editing
+- Use \`file_summary\` to read existing doc sections before editing
 - Use \`blast_radius\` output to determine which sections need updating
 
 ### 5. Delegate When Appropriate
@@ -453,7 +453,7 @@ Execute tasks from the breakdown in batches, maximizing parallelism without losi
 1. **Load tasks** — read task graph, deps, parallelism map
 2. **Execute by batch** — For each batch in the parallelism map:
    a. Dispatch assigned agents in parallel (different files = safe parallelism)
-   b. Each agent receives: task scope, affected files, acceptance criteria, code context via \`compact()\`/\`digest()\`
+   b. Each agent receives: task scope, affected files, acceptance criteria, code context via \`file_summary\`/\`digest\`
    c. Wait for all agents in batch to complete
    d. Run \`check({})\` + \`test_run({})\` after each batch
    e. Fix any failures before proceeding to next batch
@@ -569,7 +569,7 @@ Before implementation, verify alignment with requirements:
 
 1. **Load spec** — read requirements and acceptance criteria
 2. **Codebase analysis** — \`scope_map({ task: "<feature>" })\` to identify affected subsystems
-3. **Deep dive** — \`file_summary()\` + \`compact()\` on each affected module
+3. **Deep dive** — \`file_summary({ tier: 'T2' })\` on each affected module
 4. **Architecture design** — Decide on:
    - Where new code lives (new files vs extensions)
    - API surface changes
@@ -1001,7 +1001,7 @@ ${r}
 - [ ] All spec acceptance criteria verified
 - [ ] FORGE gate passed (YIELD)
 - [ ] \`{{artifacts_path}}/verify-report.md\` written with clear verdict
-`}],"aikit-basic":[{file:`README.md`,content:"# aikit:basic — Quick Development Flow\n\nQuick development flow for **bug fixes, small features, and refactoring**.\n\n## Steps\n\n| # | Step | Skill | Produces | Requires | Agents |\n|---|------|-------|----------|----------|--------|\n| 1 | **Design Gate** | `steps/design/README.md` | `design-decisions.md` | — | Researcher-Alpha, Researcher-Delta |\n| 2 | **Assessment** | `steps/assess/README.md` | `assessment.md` | `design-decisions.md` | Explorer, Researcher-Alpha |\n| 3 | **Implementation** | `steps/implement/README.md` | `progress.md` | `assessment.md` | Implementer, Frontend |\n| 4 | **Verification** | `steps/verify/README.md` | `verify-report.md` | `progress.md` | Code-Reviewer-Alpha, Security |\n\n## How It Works\n\nEach step has a **README.md**. Orchestrator reads it via `flow({ action: 'read' })` and delegates work.\n\n### Step 1: Design Gate\n- **Auto-skips** for bug fixes and refactors (produces minimal `design-decisions.md` noting the skip)\n- For small features: runs quick brainstorming, FORGE classification, and optional decision protocol\n- Read `steps/design/README.md` for the full decision tree\n\n### Step 2: Assessment\n- Explore the codebase to understand scope and impact\n- Use `search`, `scope_map`, `file_summary`, `compact` to gather context\n- Identify the approach and produce `assessment.md`\n\n### Step 3: Implementation\n- Write code following the assessment plan\n- The Orchestrator dispatches Implementer/Frontend agents with specific file scopes\n- Follow TDD practices where applicable\n\n### Step 4: Verification\n- Code review, test execution, security check\n- Run `check({})` + `test_run({})` + `blast_radius({})`\n- Produce `verify-report.md` with findings\n\n## Using Skills Inside Steps\n\nWhen the Orchestrator activates a step:\n\n1. **Read the instruction first** — `flow({ action: 'read' })` returns the current step README.md\n2. **Follow step instructions** — primary guide\n3. **Delegate to listed agents** — each step lists which agents are appropriate\n4. **Produce the required artifact** — the step's `produces` field specifies the artifact file\n5. **Check dependencies** — required prior artifacts must exist\n6. **Report status** — agents report `DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED` to the Orchestrator\n\n## Artifacts\n\nArtifacts are stored under `.flows/{topic}/`. `{{artifacts_path}}` resolves at runtime.\n"},{file:`steps/assess/README.md`,content:`---
+`}],"aikit-basic":[{file:`README.md`,content:"# aikit:basic — Quick Development Flow\n\nQuick development flow for **bug fixes, small features, and refactoring**.\n\n## Steps\n\n| # | Step | Skill | Produces | Requires | Agents |\n|---|------|-------|----------|----------|--------|\n| 1 | **Design Gate** | `steps/design/README.md` | `design-decisions.md` | — | Researcher-Alpha, Researcher-Delta |\n| 2 | **Assessment** | `steps/assess/README.md` | `assessment.md` | `design-decisions.md` | Explorer, Researcher-Alpha |\n| 3 | **Implementation** | `steps/implement/README.md` | `progress.md` | `assessment.md` | Implementer, Frontend |\n| 4 | **Verification** | `steps/verify/README.md` | `verify-report.md` | `progress.md` | Code-Reviewer-Alpha, Security |\n\n## How It Works\n\nEach step has a **README.md**. Orchestrator reads it via `flow({ action: 'read' })` and delegates work.\n\n### Step 1: Design Gate\n- **Auto-skips** for bug fixes and refactors (produces minimal `design-decisions.md` noting the skip)\n- For small features: runs quick brainstorming, FORGE classification, and optional decision protocol\n- Read `steps/design/README.md` for the full decision tree\n\n### Step 2: Assessment\n- Explore the codebase to understand scope and impact\n- Use `search`, `scope_map`, `file_summary` to gather context\n- Identify the approach and produce `assessment.md`\n\n### Step 3: Implementation\n- Write code following the assessment plan\n- The Orchestrator dispatches Implementer/Frontend agents with specific file scopes\n- Follow TDD practices where applicable\n\n### Step 4: Verification\n- Code review, test execution, security check\n- Run `check({})` + `test_run({})` + `blast_radius({})`\n- Produce `verify-report.md` with findings\n\n## Using Skills Inside Steps\n\nWhen the Orchestrator activates a step:\n\n1. **Read the instruction first** — `flow({ action: 'read' })` returns the current step README.md\n2. **Follow step instructions** — primary guide\n3. **Delegate to listed agents** — each step lists which agents are appropriate\n4. **Produce the required artifact** — the step's `produces` field specifies the artifact file\n5. **Check dependencies** — required prior artifacts must exist\n6. **Report status** — agents report `DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED` to the Orchestrator\n\n## Artifacts\n\nArtifacts are stored under `.flows/{topic}/`. `{{artifacts_path}}` resolves at runtime.\n"},{file:`steps/assess/README.md`,content:`---
 name: assess
 description: Understand scope, analyze the codebase, and identify the approach.
 ---
@@ -1044,7 +1044,7 @@ If no requirements.md exists (Design Gate was auto-skipped for bug fix/refactor)
 1. **Parse the goal** — extract what needs to change, success criteria, constraints
 2. **Search for prior work** — \`search({ query: "<task keywords>" })\` for existing decisions or related code
 3. **Map affected scope** — \`scope_map({ task: "<description>" })\` to identify files and modules involved
-4. **Analyze structure** — \`file_summary()\` on each affected file; \`compact()\` for deeper sections
+4. **Analyze structure** — \`file_summary({ files, tier: 'T1' })\` for structure; \`file_summary({ files, tier: 'T2', query })\` for deeper sections
 5. **Identify risks** — note deps, breaking-change potential, test gaps
 6. **Draft approach** — outline implementation strategy in 3–7 steps
 

package/scaffold/dist/definitions/prompts.mjs

@@ -1,11 +1,11 @@
-const e={ask:{description:`Quick research question — find answer using AI Kit + web search`,agent:`Researcher-Alpha`,tools:[`search`,`web_search`,`web_fetch`,`compact`,`file_summary`,`knowledge`,`present`],content:`## Quick Research
+const e={ask:{description:`Quick research question — find answer using AI Kit + web search`,agent:`Researcher-Alpha`,tools:[`search`,`web_search`,`web_fetch`,`knowledge`,`present`],content:`## Quick Research
 
 1. **AI Kit Recall** — Search the AI Kit index for existing answers
 2. **Web Search** — If AI Kit has no relevant results, search the web
 3. **Synthesize** — Combine findings into a clear, concise answer
 4. **Remember** — If the answer is broadly useful, persist it with \`knowledge({ action: "remember", ... })\`
 
-**Always cite sources** — AI Kit entries, file paths, or URLs.`},debug:{description:`Systematic error diagnosis: reproduce → trace → diagnose → fix → verify`,agent:`Debugger`,tools:[`search`,`symbol`,`trace`,`blast_radius`,`check`,`test_run`,`parse_output`,`compact`,`knowledge`,`present`],content:'## Debug Workflow\n\n1. **Parse Error** — Use `parse_output` on the error message/stack trace\n2. **AI Kit Recall** — Search for known issues matching this pattern\n3. **Reproduce** — Run the failing command/test to confirm\n4. **Trace** — Use `symbol` and `trace` to follow the call chain\n5. **Diagnose** — Form hypothesis, gather evidence\n6. **Fix** — Implement minimal fix\n7. **Verify** — `check` + `test_run` to confirm fix and no regressions\n8. **Remember** — Persist the fix with `knowledge({ action: "remember", category: "troubleshooting", ... })`'},implement:{description:`Full lifecycle implementation: plan → build → review → commit`,agent:`Orchestrator`,tools:[`search`,`scope_map`,`forge_ground`,`check`,`test_run`,`blast_radius`,`knowledge`,`audit`,`present`],content:`## Implementation Pipeline
+**Always cite sources** — AI Kit entries, file paths, or URLs.`},debug:{description:`Systematic error diagnosis: reproduce → trace → diagnose → fix → verify`,agent:`Debugger`,tools:[`search`,`symbol`,`trace`,`blast_radius`,`check`,`test_run`,`parse_output`,`knowledge`,`present`],content:'## Debug Workflow\n\n1. **Parse Error** — Use `parse_output` on the error message/stack trace\n2. **AI Kit Recall** — Search for known issues matching this pattern\n3. **Reproduce** — Run the failing command/test to confirm\n4. **Trace** — Use `symbol` and `trace` to follow the call chain\n5. **Diagnose** — Form hypothesis, gather evidence\n6. **Fix** — Implement minimal fix\n7. **Verify** — `check` + `test_run` to confirm fix and no regressions\n8. **Remember** — Persist the fix with `knowledge({ action: "remember", category: "troubleshooting", ... })`'},implement:{description:`Full lifecycle implementation: plan → build → review → commit`,agent:`Orchestrator`,tools:[`search`,`scope_map`,`forge_ground`,`check`,`test_run`,`blast_radius`,`knowledge`,`audit`,`present`],content:`## Implementation Pipeline
 
 Follow the Orchestrator's full workflow:
 
@@ -25,7 +25,7 @@ Refer to the Orchestrator agent's full instructions for the detailed workflow.`}
 5. **Dependency Graph** — Group into parallel batches
 6. **Present** — Show plan with open questions
 
-**🛑 MANDATORY STOP** — Wait for user approval. Do NOT implement.`},design:{description:`Collaborative design session — explore ideas, refine requirements, produce a design spec`,agent:`Orchestrator`,tools:[`search`,`scope_map`,`file_summary`,`compact`,`knowledge`,`forge_classify`,`present`],content:`## Design Session
+**🛑 MANDATORY STOP** — Wait for user approval. Do NOT implement.`},design:{description:`Collaborative design session — explore ideas, refine requirements, produce a design spec`,agent:`Orchestrator`,tools:[`search`,`scope_map`,`file_summary`,`knowledge`,`forge_classify`,`present`],content:`## Design Session
 
 Enter Phase 0 (Design Gate) directly — the user is requesting a design session.
 
@@ -52,7 +52,7 @@ Merge findings from both reviewers:
 - **Disagreements**: Contradicting verdicts → present both to user
 
 ### Step 5: Report
-Present unified review with: verdict, findings by severity, recommended actions.`},"flow-add":{description:`Install a new flow from a git URL or local path — with interactive error recovery`,agent:`Orchestrator`,tools:[`flow`,`search`,`compact`,`file_summary`,`present`],content:`## Flow Installation Assistant
+Present unified review with: verdict, findings by severity, recommended actions.`},"flow-add":{description:`Install a new flow from a git URL or local path — with interactive error recovery`,agent:`Orchestrator`,tools:[`flow`,`search`,`present`],content:`## Flow Installation Assistant
 
 Install a development flow from a git repository or local directory.
 
@@ -148,7 +148,7 @@ Manage your installed development flows.
 1. If no specific action requested, start with \`flow({ action: 'list' })\` and present overview
 2. Use \`present\` to display flow information in a clear table/card format
 3. For updates, warn if there's an active flow that might be affected
-4. For removals, confirm with user before proceeding`},"flow-create":{description:`Create a new flow from scratch or migrate an existing workflow to aikit format`,agent:`Orchestrator`,tools:[`flow`,`search`,`compact`,`file_summary`,`present`],content:`## Flow Creation Assistant
+4. For removals, confirm with user before proceeding`},"flow-create":{description:`Create a new flow from scratch or migrate an existing workflow to aikit format`,agent:`Orchestrator`,tools:[`flow`,`search`,`present`],content:`## Flow Creation Assistant
 
 Create a new development flow or migrate an existing workflow to the aikit flow format.
 
@@ -222,7 +222,7 @@ Each step README should include:
 - **Inputs** — What context/artifacts from prior steps are needed
 - **Instructions** — Detailed steps for the agent to follow
 - **Output** — What artifact(s) to produce and where to save them
-- **Acceptance criteria** — How to know the step is complete`},docs:{description:`Deep codebase understanding — analyze, learn, document, and visualize the entire project as an interactive knowledge graph`,agent:`Orchestrator`,tools:[`onboard`,`analyze`,`audit`,`produce_knowledge`,`graph`,`measure`,`blast_radius`,`search`,`symbol`,`trace`,`dead_symbols`,`file_summary`,`compact`,`digest`,`knowledge`,`present`,`check`,`test_run`,`git_context`],content:`## Understand & Document — Full Codebase Intelligence
+- **Acceptance criteria** — How to know the step is complete`},docs:{description:`Deep codebase understanding — analyze, learn, document, and visualize the entire project as an interactive knowledge graph`,agent:`Orchestrator`,tools:[`onboard`,`analyze`,`audit`,`produce_knowledge`,`graph`,`measure`,`blast_radius`,`search`,`symbol`,`trace`,`dead_symbols`,`file_summary`,`digest`,`knowledge`,`present`,`check`,`test_run`,`git_context`],content:`## Understand & Document — Full Codebase Intelligence
 
 Turn this codebase into a deeply understood, richly documented, and visually explorable project.
 "Understand Anything" philosophy: **graphs that teach > graphs that impress.**
@@ -356,7 +356,7 @@ After all phases complete, present a final summary to the user:
 - **Mark unknowns** with \`[TODO]\` and intent-dependent decisions with \`[ASK USER]\`
 - **Delegate to specialists**: architecture diagrams → \`c4-architecture\` skill, ADRs → \`adr-skill\`
 - **Compress between phases** — use \`digest\` and \`stash\` to manage context
-- **🛑 STOP after Phase 5** — present results and ask user for feedback before any follow-up work`},"docs-site":{description:`Generate interactive HTML documentation — C4 architecture viewers and code tour walkthroughs with browser verification`,agent:`Orchestrator`,tools:[`onboard`,`analyze`,`produce_knowledge`,`graph`,`search`,`symbol`,`trace`,`file_summary`,`compact`,`digest`,`knowledge`,`browser`,`present`,`check`,`git_context`,`measure`],content:`## Generate Interactive Documentation Viewers
+- **🛑 STOP after Phase 5** — present results and ask user for feedback before any follow-up work`},"docs-site":{description:`Generate interactive HTML documentation — C4 architecture viewers and code tour walkthroughs with browser verification`,agent:`Orchestrator`,tools:[`onboard`,`analyze`,`produce_knowledge`,`graph`,`search`,`symbol`,`trace`,`file_summary`,`digest`,`knowledge`,`browser`,`present`,`check`,`git_context`,`measure`],content:`## Generate Interactive Documentation Viewers
 
 Create interactive HTML documentation using C4 architecture viewers and code tour walkthroughs.
 

package/scaffold/dist/definitions/protocols.mjs

@@ -7,7 +7,7 @@ When dispatched as a subagent within an active flow:
    \`\`\`
    knowledge({ action: 'withdraw', scope: 'flow', profile: '${e}', budget: 6000 })
    \`\`\`
-  Reuse withdrawn context before re-calling \`compact\`, \`file_summary\`, \`stratum_card\`, \`scope_map\`, \`blast_radius\`, or \`search\`.
+  Reuse withdrawn context before re-calling \`file_summary\`, \`scope_map\`, \`blast_radius\`, or \`search\`.
 2. Missing in withdrawn context → call tool once. Present → reuse.
 3. **\`read_file\` ONLY** for exact edit lines.
 4. Deposit new discoveries:
@@ -30,7 +30,7 @@ AI Kit delivers knowledge through four layers:
 - **L3 — Evidence Archive**: Auto-knowledge observations and tool-output evidence. Inspect only for provenance, conflict review, or promotion assessment. Never auto-injected.
 
 ### Hot Path
-1. Session start → fetch \`aikit://l0/workspace-core\` resource (full card) or \`status({ includePrelude: true })\` (compact summary). Prerequisite: \`onboard({ path, mode: 'generate' })\` must have run for the workspace. If workspaceCore null → run onboard first, then status again. If flow active, \`workflow:<flow>\` loaded via flow context. If no flow, may add one task card via \`stratum_card\`.
+1. Session start → fetch \`aikit://l0/workspace-core\` resource (full card) or \`status({ includePrelude: true })\` (compact summary). Prerequisite: \`onboard({ path, mode: 'generate' })\` must have run for the workspace. If workspaceCore null → run onboard first, then status again. If flow active, \`workflow:<flow>\` loaded via flow context. If no flow, may add one task card via \`file_summary\`.
 2. Active flow → use L1 snapshot + dispatch refs before broad retrieval.
 3. Retrieve L2 on demand.
 4. Inspect L3 only for evidence, provenance, or promotion.
@@ -50,7 +50,7 @@ AI Kit delivers knowledge through four layers:
 - Route L1 withdrawal by configured profile; never promote.
 - Emit L3 evidence as observer-only; never navigate flow state.`:t===`flow`?r+`
 ### Step Contracts
-Each built-in flow step declares knowledge inputs (L0 card types, L1 fields, L2 refs, L3 evidence), context updates, candidate learnings, and handoff artifacts. The step knowledge contract drives role-aware L1 projection.`:r}const l=r(`## Output Rules (HARD RULE)`,`**Plain text is allowed only when ALL are true:**`,` - Response is 1-2 short sentences.`,` - No table, list, checklist, plan, report, verdict, review, summary, progress, evidence map, or batch result is being returned.`,` - No user approval, mandatory stop, or choice is needed.`,"Follow the **Presentation Priority** (1st Inline Visual - `present({ schemaVersion: 1, title, blocks })` → 2nd Interactive - `present({ schemaVersion: 1, title, blocks, actions })` → 3rd Plain Text). Only tiny status/questions that pass the gate above → plain text (Priority 3). Prefer `present` for all others, especially summaries, comparisons, reports, task plans, verdicts, and progress.");function u(){return'## Tool Preference — AI Kit First (HARD RULE)\n\n**Never start with `read_file`, `grep_search`, `semantic_search`, or `run_in_terminal`. AI Kit tools replace all of these.**\n\n| Need | Use | NEVER |\n|------|-----|-------|\n| Structure of a file | `file_summary({ path })` | `read_file` to "understand" it |\n| Find specific code | `compact({ path, query })` | `read_file` to search |\n| Multiple files | `digest({ sources, query })` | Multiple `read_file` calls |\n| Reuse previous output | `compact({ ref, query? })` with `enrich:true` | Re-reading same file |\n| Search codebase | `search({ query })` | `grep_search` / `semantic_search` |\n| Find a symbol | `symbol({ name })` | `grep_search` |\n| Trace data flow | `trace({ items: [{start, direction}] })` | Manual code tracing |\n| Module relationships | `graph({action:\'neighbors\', node_id})` | Manual import tracing |\n| Typecheck + lint | `check({})` | `run_in_terminal tsc` / biome |\n| Run tests | `test_run({})` | `run_in_terminal vitest` |\n| Impact analysis | `blast_radius({ changed_files })` | Manual caller tracing |\n| Complexity metrics | `measure({ path })` | Line counting / wc |\n| L0 briefing card (workspace-core) | `aikit://l0/workspace-core` resource (full card), `stratum_card`, `file_summary`, `compact` | Raw file discovery |\n| L0 briefing card (known issues) | `search({ query: "known issues" })` + `knowledge({ action: "lesson" })` | Manual history review |\n| Web research | `web_search({ queries })` + `web_fetch({ urls })` | `fetch_webpage` |\n\n`read_file` is ONLY acceptable when you need exact line content FOR EDITING (before `replace_string_in_file`).\n\nEven then, use `file_summary` first to identify which lines to read.'}const d=r(`## AI Kit Recovery`,"If AI Kit tools are unavailable or missing, run `npx -y @vpxa/aikit@latest init --user`, then reload the client so the `aikit` MCP server and user instructions become available."),f={"code-agent-base":`# Code Agent - Shared Kernel
+Each built-in flow step declares knowledge inputs (L0 card types, L1 fields, L2 refs, L3 evidence), context updates, candidate learnings, and handoff artifacts. The step knowledge contract drives role-aware L1 projection.`:r}const l=r(`## Output Rules (HARD RULE)`,`**Plain text is allowed only when ALL are true:**`,` - Response is 1-2 short sentences.`,` - No table, list, checklist, plan, report, verdict, review, summary, progress, evidence map, or batch result is being returned.`,` - No user approval, mandatory stop, or choice is needed.`,"Follow the **Presentation Priority** (1st Inline Visual - `present({ schemaVersion: 1, title, blocks })` → 2nd Interactive - `present({ schemaVersion: 1, title, blocks, actions })` → 3rd Plain Text). Only tiny status/questions that pass the gate above → plain text (Priority 3). Prefer `present` for all others, especially summaries, comparisons, reports, task plans, verdicts, and progress.");function u(){return'## Tool Preference — AI Kit First (HARD RULE)\n\n**Never start with `read_file`, `grep_search`, `semantic_search`, or `run_in_terminal`. AI Kit tools replace all of these.**\n\n| Need | Use | NEVER |\n|------|-----|-------|\n| Structure of a file | `file_summary({ path })` | `read_file` to "understand" it |\n| Find specific code | `file_summary({ files, tier: \'T2\', query })` | `read_file` to search |\n| Multiple files | `digest({ sources, query })` | Multiple `read_file` calls |\n| Reuse previous output | `file_summary({ ref, query })` with `enrich:true` | Re-reading same file |\n| Search codebase | `search({ query })` | `grep_search` / `semantic_search` |\n| Find a symbol | `symbol({ name })` | `grep_search` |\n| Trace data flow | `trace({ items: [{start, direction}] })` | Manual code tracing |\n| Module relationships | `graph({action:\'neighbors\', node_id})` | Manual import tracing |\n| Typecheck + lint | `check({})` | `run_in_terminal tsc` / biome |\n| Run tests | `test_run({})` | `run_in_terminal vitest` |\n| Impact analysis | `blast_radius({ changed_files })` | Manual caller tracing |\n| Complexity metrics | `measure({ path })` | Line counting / wc |\n| L0 briefing card (workspace-core) | `aikit://l0/workspace-core` resource (full card), `file_summary` | Raw file discovery |\n| L0 briefing card (known issues) | `search({ query: "known issues" })` + `knowledge({ action: "lesson" })` | Manual history review |\n| Web research | `web_search({ queries })` + `web_fetch({ urls })` | `fetch_webpage` |\n\n`read_file` is ONLY acceptable when you need exact line content FOR EDITING (before `replace_string_in_file`).\n\nEven then, use `file_summary` first to identify which lines to read.'}const d=r(`## AI Kit Recovery`,"If AI Kit tools are unavailable or missing, run `npx -y @vpxa/aikit@latest init --user`, then reload the client so the `aikit` MCP server and user instructions become available."),f={"code-agent-base":`# Code Agent - Shared Kernel
 
 > Shared protocol for code-writing agents. Role files add only role-specific behavior.
 
@@ -112,7 +112,7 @@ Blockers: <only if any>
 Keep normal status under 200 words; include full detail only for \`BLOCKED\`.
 
 ## Tool Names
-Instructions use short names such as \`status\`, \`compact\`, \`search\`. Runtime may prefix names by client, e.g. \`mcp_aikit_status\` or \`mcp__aikit__status\`. Call the tool whose name ends with the requested short name.
+Instructions use short names such as \`status\`, \`file_summary\`, \`search\`. Runtime may prefix names by client, e.g. \`mcp_aikit_status\` or \`mcp__aikit__status\`. Call the tool whose name ends with the requested short name.
 `,"researcher-base":`# Researcher - Shared Kernel
 
 > Researchers are read-only subagents for discovery, trade-offs, and decision input.
@@ -124,7 +124,7 @@ ${u()}
 ## Method
 1. Start from Orchestrator question + provided context.
 2. Recall: \`search({ query })\` + relevant lessons/conventions.
-3. Explore with \`graph\`, \`symbol\`, \`trace\`, \`find\`, \`file_summary\`, \`compact\`, \`analyze\`; web tools only for external facts.
+3. Explore with \`graph\`, \`symbol\`, \`trace\`, \`find\`, \`file_summary\`, \`analyze\`; web tools only for external facts.
 4. Synthesize into recommendation, trade-offs, risks, confidence.
 5. Persist only durable non-obvious findings.
 
@@ -327,7 +327,7 @@ Do not use for requirements discovery or feature scoping.
 | \`forge_ground\` | Execute entire Ground phase — classify tier, scope map, unknowns, constraints | Start of every Standard/Critical task |
 | \`forge_classify\` | Classify tier only (Floor/Standard/Critical) | Quick classification |
 | \`evidence_map\` | CRUD + Gate evaluation for Evidence Map | Track claims during Build |
-| \`stratum_card\` | Generate T1/T2 context cards from files | Replace full file reads |
+| \`file_summary\` | Generate T1/T2 context cards from files | Replace full file reads |
 | \`digest\` | Compress N text sources into budget | Compress accumulated context |
 
 ## Tier Classification
@@ -390,7 +390,7 @@ Use execute → score → fix → re-score:
 \`\`\`
 evidence_map({ action: "create", task_id: "add-user-api", tier: "standard" })
 evidence_map({ action: "add", ..., claim: "User schema matches existing patterns", status: "V", receipt: "search → models/user.ts#L12", safety_gate: "provenance" })
-evidence_map({ action: "add", ..., claim: "API route follows REST conventions", status: "V", receipt: "compact → routes/index.ts confirms RESTful pattern" })
+evidence_map({ action: "add", ..., claim: "API route follows REST conventions", status: "V", receipt: "file_summary → routes/index.ts confirms RESTful pattern" })
 evidence_map({ action: "add", ..., claim: "Input validation covers edge cases", status: "V", receipt: "test_run → 8/8 pass", safety_gate: "coverage" })
 evidence_map({ action: "add", ..., claim: "No breaking changes to existing API", status: "V", receipt: "blast_radius → 0 affected", safety_gate: "commitment" })
 evidence_map({ action: "gate", task_id: "add-user-api" })  → YIELD ✅