toga-ai 1.0.573 → 1.0.574

package/CLAUDE.md

@@ -42,10 +42,12 @@ bloating and tripping compaction mid-session — the exact problem this design s
 Treat your own context as a scarce budget; spend it on decisions, not on raw file
 contents.
 
-- **`/kickoff` delegates all knowledge-doc reading** to the `context-primer` subagent
-  (Step 4). It reads the architecture, feature, standard, and client docs and returns a
-  small distilled briefing plus a **"Doc map"** for just-in-time deep dives later. The
-  main thread keeps roughly ~2k tokens of primed context instead of ~8k of raw docs.
+- **`/kickoff` primes the knowledge base in the MAIN session** (Step 4) — the developer
+  reads the resolved architecture, feature, standard, and client docs directly, in this
+  thread, **synchronously**. Priming is **not** delegated to a subagent, and **no subagent
+  starts until priming is complete** (enforced by the `kickoff-gate` hook; released only by
+  `knowledge.js kickoff-primed`). This is a deliberate exception to the delegate-heavy-reading
+  principle: the team requires the primed knowledge to live in the developer's own context.
 - **`/capture` delegates the whole search/classify/draft/write/publish pipeline** to the
   `session-capture` subagent. The main thread only distills a compact **"changeset
   digest"** — the one thing a subagent cannot see, the live conversation — and handles
@@ -62,7 +64,7 @@ contents.
 
 These install into a project's `.claude/agents/toga/` via `npx toga-ai`:
 
-- **context-primer** — kickoff doc distiller; reads knowledge docs, returns briefing + Doc map.
+- **context-primer** — DEPRECATED (2026-08-13); kickoff now primes in the main session, not via this agent.
 - **session-capture** — capture write pipeline; search → classify → draft → write → publish.
 - **planner** — TOGA-aware phased planning (via `ecc:planner`).
 - **php-reviewer** — reviews PHP changes for framework standards and correctness.

package/agents/context-primer.md

@@ -1,12 +1,18 @@
 ---
 name: context-primer
-description: TOGA kickoff context loader — reads the full knowledge docs resolved by kickoff-preflight (architecture, features, standards, client docs) in its OWN context and returns a compact, distilled session primer plus a doc-map for just-in-time deep dives. Keeps the main conversation thread lean so it never trips compaction. Spawned by the /kickoff skill at Step 4, after preflight has run.
+description: DEPRECATED (2026-08-13) — no longer used by /kickoff. Team policy now requires kickoff priming to happen IN THE MAIN SESSION (the developer reads the resolved knowledge docs directly, synchronously, and no subagent runs until priming is complete). This agent formerly did that reading in its own context; it is kept only for reference and must not be spawned during kickoff (the kickoff-gate hook blocks it). Do not use.
 model: sonnet
 tools: Read, Bash, Grep, Glob
 ---
 
 # TOGA Context Primer
 
+> **⚠ DEPRECATED — 2026-08-13.** Kickoff no longer delegates knowledge-base reading to a
+> subagent. Team policy is that priming runs **in the main session**, synchronously, with **no
+> subagent** starting until priming is complete (see `skills/kickoff/SKILL.md` Step 4 and the
+> `session-priming` standard). The `kickoff-gate` hook now **blocks** spawning this agent during
+> a kickoff. This file is retained for history only; the workflow below is no longer invoked.
+
 Your job is to do the **heavy reading** of the team knowledge base so the main
 conversation does not have to. You read the full docs in *your* context window and
 return a small, high-signal briefing. The main thread keeps only your briefing — not

package/knowledge/standalone/standards/session-priming.md

@@ -0,0 +1,75 @@
+---
+title: Session priming — prime the team KB in the main session, never a subagent
+framework: "standalone"
+repo: claude
+project: Claude Harness
+client: shared
+type: standard
+status: active
+updated: 2026-08-13
+owners: ["jcardinal"]
+files:
+  - skills/kickoff/SKILL.md
+  - scripts/hooks/kickoff-gate.js
+  - knowledge.js
+related:
+  - standalone/apps/claude/workflows/mcp-tool-usage.md
+---
+
+# Session priming — prime the team KB in the main session, never a subagent
+
+When `/kickoff` runs, priming the team knowledge base — reading the resolved architecture,
+feature, standard, and client docs — **must happen in the main session.** Claude reads those
+docs **itself, directly, in the main conversation.** It must **not** hand the reading to a
+subagent, and **no other subagent may start** until priming is finished.
+
+This is a team directive. It applies to every session, both frameworks, every repo and client.
+
+## The rules
+
+1. **Priming runs in the main session.** After the interview and `kickoff-preflight`, read the
+   resolved `reads[]` docs yourself, in this thread. Do not spawn a subagent (the old
+   `context-primer`, now **deprecated**) to read them for you.
+2. **Priming is first, and synchronous.** It happens before any other research — before you
+   read a single repo file, grep the source, edit, or write. Read the docs one after another;
+   do not race other work alongside them.
+3. **No parallel subagents until priming is complete.** No `Agent`/`Task` of any kind may begin
+   until priming is done. This is the hard rule the developer asked for: nothing fans out early.
+4. **Signal completion explicitly.** When you have read **every** resolved doc, run
+   `node "<TEAM_REPO>/knowledge.js" kickoff-primed`. Only then may you read repo code, edit,
+   write, or spawn agents.
+5. **Ordering is unchanged.** The team KB stays the **first** source, ahead of all other
+   research — that part was already correct and stays.
+
+## How it is enforced
+
+The `kickoff-gate` hook (`scripts/hooks/kickoff-gate.js`) enforces this mechanically in two
+stages. Stage 2 ("primer"), entered after `kickoff-preflight`:
+
+- **allows** reading/searching docs under `knowledge/`, repo-path memory reads, and the
+  `knowledge.js` priming commands;
+- **blocks** repo-code `Read`/`Grep`/`Glob`, `Edit`, `Write`, and **every** `Agent`/`Task`
+  spawn (including the deprecated `context-primer`);
+- **releases only** on the `node knowledge.js kickoff-primed` sentinel.
+
+Emergency override: `KICKOFF_GATE_DISABLED=1`.
+
+## Why
+
+Two reasons. First, the team wants the primed knowledge to live in the **developer's own
+context**, not summarized-and-lost inside a subagent that returns only a digest — the raw
+docs stay available in-session for the whole task. Second, letting subagents fan out before
+priming is complete lets work start against un-primed context, which is exactly the mistake
+kickoff exists to prevent. Reading in the main session, synchronously, with no early
+subagents, removes both failure modes.
+
+Trade-off, accepted knowingly: reading every doc inline uses more of the main thread's context
+than the old subagent approach did. Mitigate by not re-reading absorbed docs and by reading
+only the needed section of a large spec — but priming in the main session is the requirement.
+
+## Change history
+- 2026-08-13 — Standard recorded. Kickoff priming must run in the main session, synchronously,
+  and no subagent may start until priming is complete; released by the new
+  `knowledge.js kickoff-primed` sentinel. Retired the `context-primer` subagent from the
+  kickoff flow; rewired `kickoff-gate.js` Stage 2 accordingly; updated `skills/kickoff/SKILL.md`
+  Step 4 and the ticket skills. (jcardinal)

package/knowledge.js

@@ -978,6 +978,22 @@ function cmdSkills(args) {
 /* dispatch                                                            */
 /* ------------------------------------------------------------------ */
 
+/*
+ * kickoff-primed — the explicit "team-KB priming is COMPLETE" sentinel.
+ *
+ * During /kickoff, the developer primes the team knowledge base by reading the resolved
+ * docs DIRECTLY IN THE MAIN SESSION (never via a subagent). The kickoff-gate hook holds
+ * the session in its "primer" stage — blocking all repo research, edits, and every
+ * subagent spawn — until this command runs. The model runs it only after it has read
+ * every resolved knowledge doc in the main session; the gate detects it and releases.
+ *
+ * This command intentionally does nothing but confirm — the gate keys off the command
+ * itself, so no shared state is needed here.
+ */
+function cmdKickoffPrimed() {
+    console.log('Team knowledge base primed in the main session — kickoff gate released. Priming was synchronous; no subagents ran during it.');
+}
+
 function main() {
     const [, , cmd, ...rest] = process.argv;
     const args = parseArgs(rest);
@@ -989,6 +1005,7 @@ function main() {
         case 'validate': return cmdValidate();
         case 'manifest': return cmdManifest();
         case 'kickoff-preflight': return cmdPreflight(args);
+        case 'kickoff-primed': return cmdKickoffPrimed();
         case 'publish': return cmdPublish(args);
         case 'session-save': return cmdSessionSave(args);
         case 'session-list': return cmdSessionList(args);
@@ -996,7 +1013,7 @@ function main() {
         case 'session-delete': return cmdSessionDelete(args);
         case 'skills': return cmdSkills(args);
         default:
-            console.log('Usage: node knowledge.js <search|index|deps|validate|manifest|kickoff-preflight|publish|session-save|session-list|session-show|session-delete|skills> [--flags]');
+            console.log('Usage: node knowledge.js <search|index|deps|validate|manifest|kickoff-preflight|kickoff-primed|publish|session-save|session-list|session-show|session-delete|skills> [--flags]');
             process.exitCode = 1;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toga-ai",
-  "version": "1.0.573",
+  "version": "1.0.574",
   "description": "TOGA Technology Team Claude Knowledge System — shared AI coding harness with skills, knowledge base CLI, and project installer for Claude Code.",
   "keywords": [
     "claude",

package/scripts/hooks/kickoff-gate.js

@@ -13,8 +13,8 @@
  * primed, treating the knowledge base as a side-channel instead of the first source.
  *
  * The team knowledge base is the whole point of kickoff — it is the distilled, shared
- * gold the team maintains, and it must be primed FIRST, via the `context-primer`
- * subagent, before ANY other research. This hook now enforces that in TWO stages:
+ * gold the team maintains, and it must be primed FIRST, IN THE MAIN SESSION (never via a
+ * subagent), before ANY other research. This hook enforces that in TWO stages:
  *
  *   Stage 1  ARMED   (set by /kickoff)  — allow ONLY the read-only priming steps
  *                    (version check, team-repo probe, manifest, interview) and
@@ -23,16 +23,23 @@
  *                    releases it.
  *
  *   Stage 2  PRIMER  (set by preflight) — the load-set is known but the team KB is not
- *                    yet primed. Block all repo research (Read/Grep/Glob of code, Edit,
- *                    Write, and every non-primer agent) until the `context-primer`
- *                    subagent is spawned IN THE FOREGROUND (run_in_background: false),
- *                    so the model actually waits for the briefing. Spawning it releases
- *                    the gate. Reading repo-path MEMORY files and asking the developer
- *                    remain allowed (they are part of priming).
+ *                    yet primed. The developer must read the resolved knowledge docs
+ *                    DIRECTLY IN THE MAIN SESSION. In this stage:
+ *                      • team-KB reads/searches (paths under `knowledge/`) and the
+ *                        knowledge.js priming commands are ALLOWED — this IS the priming;
+ *                      • repo code (Read/Grep/Glob), Edit, Write are BLOCKED;
+ *                      • EVERY subagent spawn (Agent/Task) is BLOCKED — no parallel agent
+ *                        may begin until priming is complete. This is the hard guarantee.
+ *                    The gate releases ONLY when the main session runs the explicit
+ *                    completion sentinel `node knowledge.js kickoff-primed`, which the
+ *                    model runs after it has read every resolved doc in the main session.
+ *                    Reading repo-path MEMORY files and asking the developer remain
+ *                    allowed (they are part of priming).
  *
  * Net effect: after the interview, the model literally cannot read a single repo file,
- * grep the code, or spawn any other agent until it has primed from the team KB via the
- * context-primer subagent. KB-first, via subagent, without exception.
+ * grep the code, edit anything, or spawn ANY subagent until it has primed the team KB
+ * itself, in the main session, and signalled completion. KB-first, main-session,
+ * synchronous, no subagents until done — without exception.
  *
  * Registered for UserPromptSubmit (arm) + PreToolUse (enforce). A defensive
  * PostToolUse branch is a no-op — release is spawn-time in PreToolUse, so the gate can
@@ -116,9 +123,27 @@ function isMemoryReadPath(p) {
   return /\.claude\/projects\/.+\/memory\//i.test(norm);
 }
 
-/* The subagent that primes the team knowledge base. It — and only it — may run in the
- * primer stage. */
-const PRIMER_SUBAGENT = 'context-primer';
+/* The explicit "team-KB priming is COMPLETE" sentinel. Running `knowledge.js kickoff-primed`
+ * in the main session is the ONLY thing that releases the primer stage — the model runs it
+ * after reading every resolved knowledge doc itself, in the main session. */
+function isPrimedSentinelBash(command) {
+  return typeof command === 'string' && /knowledge\.js["']?\s+kickoff-primed/i.test(command);
+}
+
+/* A path that lives inside the team knowledge base (`knowledge/…*.md`). Reading one is the
+ * priming act — allowed in the primer stage. Repo code paths do not match. */
+function isTeamKbPath(p) {
+  if (typeof p !== 'string' || !p) return false;
+  const norm = p.replace(/\\/g, '/');
+  return /(^|\/)knowledge\/.+\.md$/i.test(norm);
+}
+
+/* A Grep/Glob whose search root is inside the team knowledge base — the on-demand way to
+ * locate a doc while priming. Anything without a `knowledge/` root is repo research. */
+function isTeamKbSearch(toolInput) {
+  const p = (toolInput && (toolInput.path || toolInput.glob)) || '';
+  return typeof p === 'string' && /(^|[\/\\])knowledge([\/\\]|$)/i.test(p);
+}
 
 /* Tools that constitute touching the task — blocked while the gate is armed. Both the
  * classic `Task` tool and this harness's `Agent` tool are included. */
@@ -152,28 +177,21 @@ function primerMessage() {
     '🛑 KICKOFF GATE (stage 2 of 2) — the TEAM KNOWLEDGE BASE has not been primed yet.',
     '',
     'kickoff-preflight resolved the load-set, but the team KB is the FIRST source you must',
-    'prime from — before ANY other research. Do NOT read repo code, grep/glob the source,',
-    'edit, or spawn any other agent yet — not even files named in the /kickoff sentence.',
+    'prime from — before ANY other research. Prime it YOURSELF, IN THE MAIN SESSION — do',
+    'NOT spawn a subagent to do it. No subagent (Agent/Task) may run until priming is done.',
     '',
-    'Do this now (Step 4): spawn the context-primer subagent to read the resolved knowledge',
-    'docs and return the briefing —',
-    '    Agent tool · subagent_type: "context-primer" · run_in_background: false',
-    '    pass it: TEAM_REPO, the full kickoff-preflight JSON, and the task description.',
-    'Wait for its briefing. THEN read repo code and start the work.',
+    'Do this now (Step 4): Read the resolved knowledge docs directly (the preflight `reads[]`',
+    'list — architecture, features, standards, client docs under <TEAM_REPO>/knowledge/),',
+    'in this main session, one after another. Do NOT read repo code, grep/glob the source,',
+    'edit, write, or spawn any agent yet — not even files named in the /kickoff sentence.',
     '',
-    'Allowed meanwhile: reading repo-path-<repo> memory files, AskUserQuestion (to ask for',
-    'a repo path), and knowledge.js priming commands.',
-    '(Emergency override only: set KICKOFF_GATE_DISABLED=1.)',
-  ].join('\n');
-}
-
-function foregroundMessage() {
-  return [
-    '🛑 KICKOFF GATE (stage 2 of 2) — spawn the context-primer in the FOREGROUND.',
+    'When you have read EVERY resolved doc, signal completion to release the gate:',
+    '    node "<TEAM_REPO>/knowledge.js" kickoff-primed',
+    'THEN read repo code and start the work.',
     '',
-    'Pass run_in_background: false so team-KB priming actually COMPLETES before you',
-    'continue. A backgrounded primer lets you race ahead and read repo code before the',
-    'knowledge-base briefing lands — the exact failure this gate exists to prevent.',
+    'Allowed meanwhile: reading/searching docs under knowledge/, reading repo-path-<repo>',
+    'memory files, AskUserQuestion (to ask for a repo path), and knowledge.js commands.',
+    '(Emergency override only: set KICKOFF_GATE_DISABLED=1.)',
   ].join('\n');
 }
 
@@ -195,9 +213,11 @@ function main() {
         '<system-reminder>KICKOFF GATE ARMED (two stages). Stage 1: complete read-only ' +
         'priming (version check, resolve team repo, interview) then run `knowledge.js ' +
         'kickoff-preflight`. Stage 2: preflight does NOT release the gate — you must FIRST ' +
-        'prime the team knowledge base via the `context-primer` subagent (foreground, ' +
-        'run_in_background: false) BEFORE any repo Read/Grep/Glob/Edit/Write or other agent. ' +
-        'The trailing task description is Step 2 input, not permission to start.</system-reminder>'
+        'prime the team knowledge base YOURSELF, IN THE MAIN SESSION, by reading the resolved ' +
+        '`reads[]` docs directly (never via a subagent — no Agent/Task may run until priming ' +
+        'is complete), then run `knowledge.js kickoff-primed` to release. Only then may you ' +
+        'Read/Grep/Glob repo code, Edit, Write, or spawn an agent. The trailing task ' +
+        'description is Step 2 input, not permission to start.</system-reminder>'
       );
     }
     process.exit(0);
@@ -237,34 +257,36 @@ function main() {
     process.exit(0); // AskUserQuestion, Skill, TodoWrite, … — part of the interview
   }
 
-  // ============ STAGE 2: PRIMER — team KB must be primed via subagent first ============
+  // ===== STAGE 2: PRIMER — team KB must be primed IN THE MAIN SESSION, no subagents =====
   if (phase === 'primer') {
+    // No subagent may begin until priming is complete — this is the hard guarantee.
+    // Priming must run in the MAIN session; delegating it (or fanning out other agents
+    // alongside it) is exactly what this stage forbids.
     if (tool === 'Agent' || tool === 'Task') {
-      if (toolInput.subagent_type === PRIMER_SUBAGENT) {
-        // Must be foreground so the model waits for the briefing before doing anything else.
-        // (The classic `Task` tool runs synchronously; only the async `Agent` tool needs the
-        // explicit run_in_background: false.)
-        if (tool === 'Agent' && toolInput.run_in_background !== false) {
-          console.log(foregroundMessage());
-          process.exit(2);
-        }
-        clearLock(); // team-KB priming is underway in the foreground — release the gate
-        process.exit(0);
-      }
-      console.log(primerMessage()); // any other agent must wait until the KB is primed
-      process.exit(2);
-    }
-    if (tool === 'Read') {
-      if (isMemoryReadPath(toolInput.file_path || toolInput.path)) process.exit(0); // repo-path lookup
       console.log(primerMessage());
       process.exit(2);
     }
     if (tool === 'Bash') {
-      if (isPrimingBash(command)) process.exit(0);
+      // The explicit completion sentinel is the ONLY release — the model runs it after it
+      // has read every resolved doc itself, in the main session.
+      if (isPrimedSentinelBash(command)) { clearLock(); process.exit(0); }
+      if (isPrimingBash(command)) process.exit(0); // knowledge.js search/get, version check, …
       console.log(primerMessage());
       process.exit(2);
     }
-    if (BLOCKED_TOOLS.has(tool)) { console.log(primerMessage()); process.exit(2); } // Grep/Glob/Edit/Write/…
+    if (tool === 'Read') {
+      const p = toolInput.file_path || toolInput.path;
+      if (isMemoryReadPath(p)) process.exit(0); // repo-path lookup
+      if (isTeamKbPath(p)) process.exit(0);      // reading a team-KB doc IS the priming
+      console.log(primerMessage());              // repo code — blocked until primed
+      process.exit(2);
+    }
+    if (tool === 'Grep' || tool === 'Glob') {
+      if (isTeamKbSearch(toolInput)) process.exit(0); // locating a doc inside knowledge/
+      console.log(primerMessage());                    // searching repo code — blocked
+      process.exit(2);
+    }
+    if (BLOCKED_TOOLS.has(tool)) { console.log(primerMessage()); process.exit(2); } // Edit/Write/…
     process.exit(0); // AskUserQuestion (ask for a repo path), Skill, … — allowed
   }
 

package/skills/kickoff/SKILL.md

@@ -33,13 +33,18 @@ description: Start-of-session context loader for TOGA Technology projects. Run t
 >   are permitted. Running **preflight (Step 3) does NOT release the gate — it advances it to
 >   stage 2.**
 > - **Stage 2 (primer):** the load-set is resolved but the **team knowledge base is not yet
->   primed.** Everything stays blocked until you spawn the **`context-primer` subagent in the
->   foreground** (Step 4) — priming the team KB via that subagent is **what releases the gate.**
->   Reading `repo-path-<repo>` memories and asking the developer stay allowed.
+>   primed.** You must prime it **yourself, in this main session** — reading the resolved
+>   knowledge docs directly (Step 4). **No subagent may run** (`Agent`/`Task` are blocked),
+>   and repo code/`Edit`/`Write` stay blocked, **until priming is complete**. The gate
+>   releases **only** when you run the completion sentinel `node "<TEAM_REPO>/knowledge.js"
+>   kickoff-primed`. Reading `repo-path-<repo>` memories, reading/searching under
+>   `knowledge/`, and asking the developer stay allowed.
 >
 > So the correct response to a block message is never to fight it: run Steps 0–3, then
-> **prime the team KB via the foreground `context-primer` subagent (Step 4) BEFORE any other
-> research** — before you open a single repo file, even one named in the `/kickoff` sentence.
+> **read the resolved team-KB docs yourself in the main session (Step 4) BEFORE any other
+> research** — before you open a single repo file, even one named in the `/kickoff` sentence —
+> and run `knowledge.js kickoff-primed` when done to release the gate. **Do not spawn a
+> subagent to do the reading, and do not start any other agent until priming is complete.**
 > (Emergency override only: `KICKOFF_GATE_DISABLED=1`.)
 
 ## Session permission policy — auto-accept local file I/O, ALWAYS confirm dangerous execution
@@ -266,43 +271,53 @@ source — this is the one thing preflight can't know):
 
 Never ask for a repo not in `loadSet`.
 
-## Step 4 — Prime the team knowledge base FIRST, via the `context-primer` subagent
+## Step 4 — Prime the team knowledge base FIRST, in the MAIN SESSION (no subagent)
 
 > 🛑 **THIS IS THE FIRST RESEARCH YOU DO — NOT OPTIONAL, NOT PARALLELIZABLE.**
 > After the interview, the team knowledge base is the **first source you prime from, before
-> ANY other research.** You may **not** read repo code, `Grep`/`Glob` the source, spawn any
-> other agent, or open a file **named in the `/kickoff` sentence** until the `context-primer`
-> subagent has **returned its briefing.** Preflight (Step 3) did **not** release the gate — it
-> advanced it to stage 2, and **spawning the foreground `context-primer` is what releases it.**
-> The team KB is the team's distilled, shared gold: skipping it, or side-channeling it (running
-> the primer in the background while you read code in parallel), is the exact failure this gate
-> exists to prevent — do neither.
-
-**This is also the token-discipline core of kickoff.** Reading every architecture + feature +
-standard + client doc *into this conversation* bloats the thread and trips compaction later. So
-you do **not** read those docs here — you **delegate the heavy reading to the `context-primer`
-subagent**, which reads them in *its own* context and returns a small distilled briefing.
-
-Spawn it with the `Agent` tool and **wait for it**:
-- `subagent_type: context-primer`,
-- **`run_in_background: false`** — foreground, so you MUST wait for the briefing before doing
-  anything else; a backgrounded primer running while you read code is precisely the violation,
-- pass it: `TEAM_REPO` (the resolved path), the **full `kickoff-preflight` JSON** from Step 3
-  (`reads[]`, `clientScope`, `standards`, `client`, `estimate`), and the developer's one-line
-  task description.
-
-The primer returns a `## Primer` block (critical rules, task-relevant knowledge + gotchas,
-client variations, gaps) plus a `## Doc map`. **Keep only that briefing as your context for
-the session — do not re-read the underlying docs.** The `reads[]` order/precedence and
-`1.0`/`2.0` union are already handled inside the primer; do not run `search`/`deps` here.
-
-**Just-in-time deep dives.** When a *specific* task later needs the full internals of one
-doc (a full architecture, a long feature spec), open just that one `path` from the Doc map
-at that moment — or, for anything large, spawn a focused reader/implementer subagent that
-reads it in its context. Never bulk-load the Doc map back into this thread "to be safe."
-
-**`exists:false` entries** appear in the primer's *Gaps* section — note them in Step 5 as
-"no knowledge captured yet."
+> ANY other research** — and you prime it **yourself, in this main session.** You may **not**
+> read repo code, `Grep`/`Glob` the source, edit, write, or **spawn any subagent** (not the
+> reading, and not any other agent running alongside it), or open a file **named in the
+> `/kickoff` sentence**, until you have finished priming and run the completion sentinel.
+> Preflight (Step 3) did **not** release the gate — it advanced it to stage 2. **Reading the
+> resolved docs in the main session and then running `knowledge.js kickoff-primed` is what
+> releases it.** The team KB is the team's distilled, shared gold: skipping it, or
+> side-channeling it (delegating the reading to a subagent, or fanning out parallel agents
+> before priming is done), is the exact failure this gate exists to prevent.
+
+**Priming is synchronous and runs here, in the main thread — never a subagent.** A previous
+design delegated the reading to a `context-primer` subagent to keep this thread lean; that is
+**no longer done**. The team's requirement is that priming happens in the main session, so the
+developer's own context holds the primed knowledge, and **no parallel agent begins until
+priming is complete.**
+
+Do this now:
+1. Walk the preflight **`reads[]`** list **in order** and `Read` each entry directly, in this
+   session:
+   - **`lazy: true` (label `architecture-summary`)** — do **not** open the file; the entry
+     already carries an inline `summary`. Absorb its **Critical rules** from that summary.
+   - **Any other entry** with `exists: true` (`repo-architecture`, `feature`, `standard`,
+     `client-profile`, `client-doc`) — `Read` the `path` resolved against
+     `<TEAM_REPO>/knowledge/`.
+   - **`exists: false`** — skip; note it as "no knowledge captured yet" for Step 5.
+   The `reads[]` order/precedence and the `1.0`/`2.0` union are already resolved by preflight —
+   do **not** run `search`/`deps` again.
+2. As you read, hold the **load-bearing facts** you'll code against: the critical rules
+   (naming prefixes, DB-access layer, dispatch pattern, response envelope, migration filename
+   rules), the task-relevant feature entry points and **gotchas**, and any client variations.
+3. When you have read **every** resolved doc, run the completion sentinel to release the gate:
+   ```bash
+   node "<TEAM_REPO>/knowledge.js" kickoff-primed
+   ```
+   Only after this may you read repo code, edit, write, or spawn any agent.
+
+**Token discipline (still matters).** Reading every doc inline is heavier than the old
+subagent approach — so be selective *after* the required reads: don't re-read a doc you've
+already absorbed, and for a large architecture/feature spec you only need part of, read the
+relevant section rather than the whole file. Keep a mental **doc map** (path → one line) so
+you can reopen a specific doc just-in-time later instead of holding it all at once.
+
+**`exists:false` entries** are *Gaps* — note them in Step 5 as "no knowledge captured yet."
 
 **Do NOT create or modify any `CLAUDE.md` stub** — kickoff only reads. A blank session is a
 valid choice; this skill is opt-in.
@@ -392,7 +407,7 @@ loaded here.
 
 ## Step 6 — Propose a workflow plan (multi-agent by default for non-trivial work)
 
-After the primer, analyze what the developer is building and **propose a concrete plan
+After priming, analyze what the developer is building and **propose a concrete plan
 before writing code**. The plan's *shape* depends on size — and the default for anything
 non-trivial is to **orchestrate specialist subagents**, not to do everything in this
 thread. This keeps the main conversation as the orchestrator (light, durable) while the
@@ -410,9 +425,9 @@ Frame everything in plain terms: "Here's my plan."
   right." Drive it as **explore → implement → verify**, delegating each stage to a subagent
   so this thread stays the conductor:
   1. **Explore/plan** — spawn `planner` (TOGA-aware) to produce a phased plan grounded in
-     the primer. It reads deep docs in its own context; you keep the plan.
+     your priming notes. It reads deep docs in its own context; you keep the plan.
   2. **Implement** — for each phase, an implementer subagent writes the code (it can open
-     the full architecture/feature docs from the primer's Doc map as needed). For work that
+     the full architecture/feature docs from your doc map as needed). For work that
      spans **independent files in parallel**, give each implementer **`isolation: worktree`**
      so they cannot collide on the same checkout.
   3. **Verify** — run the specialist reviewers (`php-reviewer`, `sql-reviewer`,
@@ -478,7 +493,8 @@ needed for those.
 
 Spawn specialists via the `Agent` tool. Grant only the tools the agent needs. Inject the
 TOGA context prefix (see `.claude/agents/toga/planner.md`, `php-reviewer.md`) — but you can
-now pass the **Step 4 primer** as that context instead of re-reading docs.
+now pass your **Step 4 priming notes** (the facts you absorbed reading the KB in the main
+session) as that context instead of re-reading docs.
 
 | Work type | Agent | Tools |
 |-----------|-------|-------|
@@ -515,7 +531,7 @@ decides when it's done.
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Context: <repo> · Framework <fw> · Client: <client>   (primed via context-primer)
+Context: <repo> · Framework <fw> · Client: <client>   (primed in main session)
 Specialists on standby: planner, php-reviewer, sql-reviewer, security-reviewer
 Bigger/iterative work → /toga-loop
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/skills/plan-ticket/SKILL.md

@@ -99,7 +99,7 @@ it goes straight to preflight + priming, e.g.:
 **Only stop to ask the developer if a gate answer is genuinely ambiguous** after all three
 inputs (e.g. the code spans both frameworks and neither ticket nor Talos says which is in
 scope). Otherwise let kickoff run unattended — it checks for harness updates, resolves the
-load-set, and returns the `context-primer` briefing.
+load-set, and primes the team knowledge base in the main session (kickoff Step 4).
 
 **Carry the primer briefing into synthesis.** The framework rules, gotchas, and client
 variations it surfaces directly inform the plan — fold them into the **Architecture decision**

package/skills/rework-ticket/SKILL.md

@@ -96,7 +96,7 @@ plan's `Repos:` header (map repos → framework/layer/client), passing the chang
 /kickoff <framework> <layer>, repos: <repos>, client: <client> — rework <TICKET> <title>: <one-line change summary>
 ```
 
-Carry the `context-primer` briefing into Step 5. Only stop to ask if a kickoff gate answer is
+Carry the kickoff priming notes (read in the main session per kickoff Step 4) into Step 5. Only stop to ask if a kickoff gate answer is
 genuinely ambiguous.
 
 ## Step 4 — Check out each EXISTING branch (fetch first; do NOT create a new branch)

package/skills/work-ticket/SKILL.md

@@ -64,8 +64,8 @@ Pass them as the trailing argument so kickoff goes straight to preflight + primi
 /kickoff <framework> <layer>, repos: <repos>, client: <client> — execute <TICKET> <title>
 ```
 
-Carry the `context-primer` briefing (framework rules, gotchas, client variations) into Step 4 —
-it directly informs how each phase is implemented. Only stop to ask the developer if a kickoff
+Carry the kickoff priming notes (framework rules, gotchas, client variations — read in the main
+session per kickoff Step 4) into Step 4 — they directly inform how each phase is implemented. Only stop to ask the developer if a kickoff
 gate answer is genuinely ambiguous after reading the plan header.
 
 ## Step 3 — Per repo: create & checkout the ticket branch BEFORE any edits