@event4u/agent-config 7.5.0 → 8.0.0

package/src/scripts/fold_intake.ts

@@ -0,0 +1,281 @@
+#!/usr/bin/env tsx
+/**
+ * Idempotent extractive fold rollup over the gitignored intake JSONL —
+ * road-to-second-brain Phase 3 (council 2026-07-07, verdict:
+ * `agents/settings/contexts/second-brain-delta-verdict.md`).
+ *
+ * Deterministic compression for the linearly-growing intake stream:
+ *   - **2^k batching** — consecutive, non-overlapping batches of
+ *     `--batch-size` events (default 32; must be a power of two) in stable
+ *     file+line order. Only COMPLETE batches fold; the tail stays live.
+ *   - **Deterministic fold IDs** — sha256 over the batch's raw JSONL lines,
+ *     first 12 hex chars. Same input → same ID, always.
+ *   - **Children never mutated** — the intake files are read-only to this
+ *     script; a fold is an ADDITIVE archive page with link-backs
+ *     (`<file>:<first-line>-<last-line>` per child range), never a rewrite.
+ *   - **Idempotent** — an existing `fold-<id>.md` is skipped, so re-runs are
+ *     no-ops and interrupted runs resume cleanly.
+ *
+ * MANUAL TRIGGER ONLY (council decision): this script is deliberately NOT
+ * wired into hooks or CI. The Phase-0 intake tripwire
+ * (`lint_knowledge_scale.ts`, intake > 2000 events) names this script as its
+ * pre-decided activation path — when it fires, wire the script into the
+ * post-session/CI cadence. Tracked files (`agents/knowledge/sessions/`) are
+ * NEVER fold-compressed here; that path requires the consolidate gate.
+ *
+ * Usage:
+ *   fold_intake.ts [--intake-dir agents/knowledge/intake]
+ *                  [--out-dir agents/memory/archive]
+ *                  [--batch-size 32] [--dry-run] [--format text|json]
+ *
+ * Exit codes: 0 = ok (including nothing-to-fold), 2 = usage error,
+ * 3 = internal error.
+ */
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const PROG = 'fold_intake.ts';
+
+export const DEFAULT_BATCH_SIZE = 32;
+const DEFAULT_INTAKE_DIR = path.join('agents', 'knowledge', 'intake');
+const DEFAULT_OUT_DIR = path.join('agents', 'memory', 'archive');
+const SNIPPET_CHARS = 140;
+
+export interface IntakeLine {
+    file: string; // relative or absolute path as discovered
+    line: number; // 1-based line number within the file
+    raw: string; // raw JSONL line (trimmed)
+}
+
+export interface FoldPlan {
+    id: string;
+    index: number; // 0-based batch index in the stable order
+    children: IntakeLine[];
+}
+
+function listIntakeFiles(dir: string): string[] {
+    let names: string[];
+    try {
+        names = fs.readdirSync(dir);
+    } catch {
+        return [];
+    }
+    return names
+        .filter((n) => n.startsWith('events-') && n.endsWith('.jsonl'))
+        .sort()
+        .map((n) => path.join(dir, n));
+}
+
+/** Stable event order: sorted(files) then line order. Children read-only. */
+export function readIntakeLines(dir: string): IntakeLine[] {
+    const out: IntakeLine[] = [];
+    for (const file of listIntakeFiles(dir)) {
+        let text: string;
+        try {
+            text = fs.readFileSync(file, 'utf-8');
+        } catch {
+            continue;
+        }
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const raw = (lines[i] ?? '').trim();
+            if (!raw) continue;
+            out.push({ file, line: i + 1, raw });
+        }
+    }
+    return out;
+}
+
+export function foldId(children: IntakeLine[]): string {
+    const h = createHash('sha256');
+    for (const c of children) {
+        h.update(c.raw);
+        h.update('\n');
+    }
+    return h.digest('hex').slice(0, 12);
+}
+
+/** Consecutive complete batches of `batchSize`; the tail stays unfolded. */
+export function planFolds(lines: IntakeLine[], batchSize: number): FoldPlan[] {
+    const plans: FoldPlan[] = [];
+    const complete = Math.floor(lines.length / batchSize);
+    for (let b = 0; b < complete; b++) {
+        const children = lines.slice(b * batchSize, (b + 1) * batchSize);
+        plans.push({ id: foldId(children), index: b, children });
+    }
+    return plans;
+}
+
+function snippet(raw: string): string {
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(raw);
+    } catch {
+        return raw.slice(0, SNIPPET_CHARS);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return raw.slice(0, SNIPPET_CHARS);
+    }
+    const e = parsed as Record<string, unknown>;
+    const ts = typeof e.ts === 'string' ? e.ts : '';
+    const type = typeof e.type === 'string' ? e.type : 'event';
+    // First string field that carries the claim, by event-type precedence.
+    const claim =
+        [e.pattern, e.correction, e.endpoint, e.observation, e.body, e.text].find(
+            (v): v is string => typeof v === 'string' && v.trim().length > 0,
+        ) ?? '';
+    const oneLine = claim.replace(/\s+/g, ' ').trim();
+    const clipped = oneLine.length > SNIPPET_CHARS ? oneLine.slice(0, SNIPPET_CHARS - 1) + '…' : oneLine;
+    return [ts, type, clipped].filter(Boolean).join(' · ');
+}
+
+/** Contiguous per-file line ranges for the link-back section. */
+export function childRanges(children: IntakeLine[]): string[] {
+    const ranges: string[] = [];
+    let start: IntakeLine | null = null;
+    let prev: IntakeLine | null = null;
+    const flush = (): void => {
+        if (start && prev) {
+            ranges.push(
+                start.line === prev.line
+                    ? `${start.file}:${start.line}`
+                    : `${start.file}:${start.line}-${prev.line}`,
+            );
+        }
+    };
+    for (const c of children) {
+        if (prev && c.file === prev.file && c.line === prev.line + 1) {
+            prev = c;
+            continue;
+        }
+        flush();
+        start = c;
+        prev = c;
+    }
+    flush();
+    return ranges;
+}
+
+export function renderFold(plan: FoldPlan, batchSize: number): string {
+    const lines: string[] = [
+        `# Fold ${plan.id}`,
+        '',
+        '> Idempotent extractive rollup of a completed intake batch',
+        `> (batch ${plan.index}, size ${batchSize}). Children are never mutated —`,
+        '> this page is an additive archive with link-backs, not a rewrite.',
+        '> Generated by `src/scripts/fold_intake.ts` (deterministic, no LLM).',
+        '',
+        `Fold ID: ${plan.id}`,
+        `Batch index: ${plan.index}`,
+        `Events: ${plan.children.length}`,
+        '',
+        '## Extract',
+        '',
+    ];
+    for (const c of plan.children) {
+        lines.push(`- ${snippet(c.raw)}`);
+    }
+    lines.push('', '## Children (link-backs)', '');
+    for (const r of childRanges(plan.children)) {
+        lines.push(`- ${r}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+
+function main(argv: string[]): number {
+    let intakeDir = DEFAULT_INTAKE_DIR;
+    let outDir = DEFAULT_OUT_DIR;
+    let batchSize = DEFAULT_BATCH_SIZE;
+    let dryRun = false;
+    let format = 'text';
+
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = (): string => {
+            const v = argv[++i];
+            if (v === undefined) {
+                process.stderr.write(`${PROG}: error: ${a} requires a value\n`);
+                process.exit(2);
+            }
+            return v;
+        };
+        if (a === '--intake-dir') intakeDir = next();
+        else if (a === '--out-dir') outDir = next();
+        else if (a === '--batch-size') {
+            batchSize = Number(next());
+            if (!Number.isInteger(batchSize) || batchSize < 2 || (batchSize & (batchSize - 1)) !== 0) {
+                process.stderr.write(`${PROG}: error: --batch-size must be a power of two >= 2\n`);
+                return 2;
+            }
+        } else if (a === '--dry-run') dryRun = true;
+        else if (a === '--format') {
+            format = next();
+            if (format !== 'text' && format !== 'json') {
+                process.stderr.write(`${PROG}: error: --format must be text|json\n`);
+                return 2;
+            }
+        } else if (a === '-h' || a === '--help') {
+            process.stdout.write(
+                `usage: ${PROG} [--intake-dir <dir>] [--out-dir <dir>] ` +
+                    `[--batch-size <2^k>] [--dry-run] [--format text|json]\n`,
+            );
+            return 0;
+        } else {
+            process.stderr.write(`${PROG}: error: unknown argument ${a}\n`);
+            return 2;
+        }
+    }
+
+    try {
+        const lines = readIntakeLines(intakeDir);
+        const plans = planFolds(lines, batchSize);
+        const results: Array<{ id: string; index: number; events: number; action: string }> = [];
+
+        for (const plan of plans) {
+            const target = path.join(outDir, `fold-${plan.id}.md`);
+            let action: string;
+            if (fs.existsSync(target)) {
+                action = 'exists (skipped — idempotent)';
+            } else if (dryRun) {
+                action = 'would write';
+            } else {
+                fs.mkdirSync(outDir, { recursive: true });
+                const tmp = `${target}.tmp-${process.pid}`;
+                fs.writeFileSync(tmp, renderFold(plan, batchSize), 'utf-8');
+                fs.renameSync(tmp, target);
+                action = 'written';
+            }
+            results.push({ id: plan.id, index: plan.index, events: plan.children.length, action });
+        }
+
+        const tail = lines.length - plans.length * batchSize;
+        if (format === 'json') {
+            process.stdout.write(
+                JSON.stringify(
+                    { dry_run: dryRun, batch_size: batchSize, total_events: lines.length, unfolded_tail: tail, folds: results },
+                    null,
+                    2,
+                ) + '\n',
+            );
+        } else {
+            for (const r of results) {
+                process.stdout.write(`fold-${r.id}  batch=${r.index}  events=${r.events}  ${r.action}\n`);
+            }
+            process.stdout.write(
+                `${PROG}: ${results.length} fold(s), ${tail} event(s) in the live tail (batch size ${batchSize}${dryRun ? ', dry-run' : ''})\n`,
+            );
+        }
+        return 0;
+    } catch (exc) {
+        process.stderr.write(`${PROG}: internal error: ${String(exc)}\n`);
+        return 3;
+    }
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/generate_capability_matrix.ts

@@ -65,7 +65,7 @@ const HOSTS = [
     'windsurf', 'cline', 'gemini', 'copilot', 'claude-desktop',
 ];
 
-const ARTIFACTS = ['rules', 'skills', 'commands', 'personas', 'user-types', 'hooks'];
+const ARTIFACTS = ['rules', 'skills', 'commands', 'subagents', 'personas', 'user-types', 'hooks'];
 
 interface FnSpec {
     artifact: string;
@@ -109,6 +109,14 @@ const _FN_SPEC: Record<string, FnSpec> = {
         artifact: 'commands',
         cells: { 'claude-code': 'native', augment: 'native' },
     },
+    generate_claude_subagents: {
+        artifact: 'subagents',
+        cells: { 'claude-code': 'native' },
+    },
+    generate_subagent_host_contexts: {
+        artifact: 'subagents',
+        cells: { cursor: 'adapter', windsurf: 'adapter', cline: 'adapter' },
+    },
     generate_plugin_command_skills: {
         artifact: 'skills', cells: { 'claude-plugin': 'native' },
     },

package/src/scripts/generate_knowledge_index.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env tsx
+/**
+ * Generate `agents/knowledge/INDEX.md` — the one-line catalog over every
+ * knowledge surface: the flat anti-hallucination cards (ADR-100) plus the
+ * lifecycle-typed sibling directories (`sessions/`, `concepts/`,
+ * `procedures/`, `decisions/`) added by road-to-knowledge-system.
+ *
+ * Design per the 2026-07-05 council verdict (Option C — extend
+ * `agents/knowledge/` in place): ONE index, index-first + grep retrieval,
+ * no search infrastructure. This script is the deterministic backstop —
+ * agents read INDEX.md first, grep second, read specific files third.
+ *
+ * Deterministic and idempotent: same inputs always produce byte-identical
+ * output. No network, no LLM calls.
+ *
+ * Usage:
+ *   generate_knowledge_index.ts [--dir <repo-root>] [--check] [--quiet]
+ *
+ * Exit codes: 0 = written / no drift, 1 = drift found (--check) or usage
+ * error, 3 = internal error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+
+const _HERE = fileURLToPath(import.meta.url);
+const PROG = 'generate_knowledge_index.ts';
+
+const FRONTMATTER_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n/;
+
+// Section order is fixed — cards first (the pre-existing anti-hallucination
+// store), then the lifecycle-typed dirs in capture-order (episodic → semantic
+// → procedural → decisions).
+const SECTIONS: ReadonlyArray<{ heading: string; dir: string | null }> = [
+    { heading: 'Knowledge Cards', dir: null }, // flat *.md directly under agents/knowledge/
+    { heading: 'Sessions', dir: 'sessions' },
+    { heading: 'Concepts', dir: 'concepts' },
+    { heading: 'Procedures', dir: 'procedures' },
+    { heading: 'Decisions', dir: 'decisions' },
+];
+
+const SKIP_FILES = new Set(['README.md', 'INDEX.md']);
+const MAX_SUMMARY_CHARS = 140;
+
+interface Entry {
+    file: string; // basename, e.g. "stripe-webhooks.md"
+    relPath: string; // path relative to agents/knowledge/, POSIX separators
+    summary: string;
+}
+
+function readFrontmatter(body: string): Record<string, unknown> {
+    const m = FRONTMATTER_RE.exec(body);
+    if (m?.[1] === undefined) return {};
+    try {
+        const parsed = YAML.parse(m[1]);
+        return parsed && typeof parsed === 'object' ? (parsed as Record<string, unknown>) : {};
+    } catch {
+        return {};
+    }
+}
+
+function stripFrontmatter(body: string): string {
+    return body.replace(FRONTMATTER_RE, '');
+}
+
+function firstHeadingOrLine(body: string): string {
+    for (const line of body.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        return trimmed.replace(/^#+\s*/, '');
+    }
+    return '';
+}
+
+function truncate(s: string, max: number): string {
+    if (s.length <= max) return s;
+    return s.slice(0, max - 1).trimEnd() + '…';
+}
+
+/** Derive a one-line summary: frontmatter `description`/`summary` wins; else the first heading/line after frontmatter. */
+function summarize(body: string): string {
+    const fm = readFrontmatter(body);
+    const fromFrontmatter = (fm.description ?? fm.summary) as unknown;
+    if (typeof fromFrontmatter === 'string' && fromFrontmatter.trim()) {
+        return truncate(fromFrontmatter.trim(), MAX_SUMMARY_CHARS);
+    }
+    const rest = stripFrontmatter(body);
+    return truncate(firstHeadingOrLine(rest), MAX_SUMMARY_CHARS);
+}
+
+function listMarkdownFiles(dirPath: string): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md') && !SKIP_FILES.has(e.name))
+        .map((e) => e.name)
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+
+function collectSection(knowledgeRoot: string, dir: string | null): Entry[] {
+    const scanDir = dir ? path.join(knowledgeRoot, dir) : knowledgeRoot;
+    const files = listMarkdownFiles(scanDir);
+    const out: Entry[] = [];
+    for (const file of files) {
+        const abs = path.join(scanDir, file);
+        let body = '';
+        try {
+            body = fs.readFileSync(abs, 'utf8');
+        } catch {
+            continue;
+        }
+        const relPath = dir ? `${dir}/${file}` : file;
+        out.push({ file, relPath, summary: summarize(body) });
+    }
+    return out;
+}
+
+function renderIndex(knowledgeRoot: string): string {
+    const lines: string[] = [];
+    lines.push('# Knowledge Index');
+    lines.push('');
+    lines.push(
+        '_Auto-generated by `src/scripts/generate_knowledge_index.ts` — do not edit by hand. Regenerate with `task generate-knowledge-index`._',
+    );
+    lines.push('');
+    lines.push(
+        '_Retrieval protocol: read this index first, `grep` for keywords second, read the specific file third. Never enumerate every knowledge file directly._',
+    );
+
+    for (const section of SECTIONS) {
+        const entries = collectSection(knowledgeRoot, section.dir);
+        if (entries.length === 0) continue;
+        lines.push('');
+        // Entry count in the heading — cheap human scannability
+        // (road-to-second-brain Phase 4: the council-endorsed browsability
+        // alternative to a vault view).
+        lines.push(`## ${section.heading} (${entries.length})`);
+        lines.push('');
+        for (const e of entries) {
+            const title = e.file.replace(/\.md$/, '');
+            const suffix = e.summary ? ` — ${e.summary}` : '';
+            lines.push(`- [${title}](${e.relPath})${suffix}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+
+function printUsage(): void {
+    process.stdout.write(`usage: ${PROG} [--dir DIR] [--check] [--quiet]\n`);
+}
+
+export function main(argv: string[]): number {
+    let dir = process.cwd();
+    let check = false;
+    let quiet = false;
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '-h' || arg === '--help') {
+            printUsage();
+            return 0;
+        } else if (arg === '--dir') {
+            const value = argv[++i];
+            if (!value) {
+                process.stderr.write(`${PROG}: error: --dir requires a value\n`);
+                return 1;
+            }
+            dir = value;
+        } else if (arg === '--check') {
+            check = true;
+        } else if (arg === '--quiet') {
+            quiet = true;
+        } else {
+            process.stderr.write(`${PROG}: error: unrecognized argument: ${arg}\n`);
+            printUsage();
+            return 1;
+        }
+    }
+
+    const knowledgeRoot = path.join(dir, 'agents', 'knowledge');
+    if (!fs.existsSync(knowledgeRoot)) {
+        if (!quiet) {
+            process.stdout.write(`${PROG}: ${knowledgeRoot} does not exist — nothing to index.\n`);
+        }
+        return 0;
+    }
+
+    const rendered = renderIndex(knowledgeRoot);
+    const indexPath = path.join(knowledgeRoot, 'INDEX.md');
+    const existing = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, 'utf8') : null;
+
+    if (check) {
+        if (existing === rendered) {
+            if (!quiet) process.stdout.write(`${PROG}: agents/knowledge/INDEX.md is up to date.\n`);
+            return 0;
+        }
+        process.stderr.write(
+            `${PROG}: agents/knowledge/INDEX.md is stale — run without --check to regenerate.\n`,
+        );
+        return 1;
+    }
+
+    if (existing === rendered) {
+        if (!quiet) process.stdout.write(`${PROG}: agents/knowledge/INDEX.md already up to date.\n`);
+        return 0;
+    }
+
+    fs.writeFileSync(indexPath, rendered, 'utf8');
+    if (!quiet) process.stdout.write(`${PROG}: wrote agents/knowledge/INDEX.md\n`);
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/hook_manifest.yaml

@@ -18,6 +18,18 @@ concerns:
     script: src/scripts/chat_history.ts
     args: [hook-dispatch]
     fail_closed: false
+  # Hot-context working-memory cache (road-to-second-brain Phase 1).
+  # stop: deterministic, redacted 400-word overwrite of
+  # agents/runtime/state/hot-context.md from the chat-history JSONL.
+  # session_start: staleness-checked restore; the dispatcher forwards the
+  # returned `context` block to its own stdout (Claude Code SessionStart
+  # injection; on Claude, source=compact re-injects after compaction).
+  # Runs AFTER chat-history in both slots so the stop-write sees the final
+  # session entries. Never blocks.
+  hot-context:
+    script: src/scripts/hot_context_hook.ts
+    args: []
+    fail_closed: false
   roadmap-progress:
     script: src/scripts/roadmap_progress_hook.ts
     args: []
@@ -116,16 +128,16 @@ concerns:
 
 platforms:
   augment:
-    session_start:    [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:    [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:      [chat-history]
-    stop:             [chat-history, verify-before-complete]
+    stop:             [chat-history, hot-context, verify-before-complete]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
     post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
 
   claude:
-    session_start:    [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:    [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:      [chat-history]
-    stop:             [chat-history, verify-before-complete]
+    stop:             [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
     post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
@@ -145,9 +157,9 @@ platforms:
   # Decision matrix + upstream blockers tracked in
   # agents/settings/contexts/chat-history-platform-hooks.md § Cowork.
   cowork:
-    session_start:    [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:    [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:      [chat-history]
-    stop:             [chat-history, verify-before-complete]
+    stop:             [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
     post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
@@ -160,9 +172,9 @@ platforms:
   # IDE-only — CLI-only users fall back to /checkpoint per
   # agents/settings/contexts/chat-history-platform-hooks.md.
   cursor:
-    session_start:      [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:      [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:        [chat-history]
-    stop:               [chat-history, verify-before-complete]
+    stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
 
@@ -175,9 +187,9 @@ platforms:
   # both map to session_start. TaskCancel maps to stop because the
   # session is interrupted with partial state (mirrors Augment Stop).
   cline:
-    session_start:      [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:      [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:        [chat-history]
-    stop:               [chat-history, verify-before-complete]
+    stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
 
@@ -194,8 +206,8 @@ platforms:
   # surface to record verification commands; documented limitation).
   # minimal-safe-diff is omitted entirely on Windsurf for the same reason.
   windsurf:
-    session_start:      [chat-history, first-run-gate, onboarding-gate, verify-before-complete, profile-staleness, wrapper-freshness]
-    stop:               [chat-history, verify-before-complete]
+    session_start:      [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, profile-staleness, wrapper-freshness]
+    stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete]
 
   # Phase 7.8 — Gemini CLI. Hooks live at `.gemini/settings.json`
@@ -209,9 +221,9 @@ platforms:
   # turn-check semantics. AfterAgent fires when the agent loop ends
   # — this is our `stop` slot.
   gemini:
-    session_start:      [chat-history, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
+    session_start:      [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness]
     session_end:        [chat-history]
-    stop:               [chat-history, verify-before-complete]
+    stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
 

package/src/scripts/hooks/dispatch_hook.ts

@@ -786,6 +786,13 @@ export function main(argv?: string[]): number {
   const started_at = _now_iso();
   const rcs: number[] = [];
   const feedback_entries: FeedbackEntry[] = [];
+  // session_start context forwarding (road-to-second-brain Phase 1): a
+  // concern may return {"context": "<string>"} in its stdout JSON; on
+  // session_start the dispatcher forwards those blocks to its OWN stdout so
+  // the host adds them to the session context (Claude Code SessionStart
+  // stdout-injection; harmless surfacing elsewhere). All other events keep
+  // the swallow-stdout contract unchanged.
+  const context_blocks: string[] = [];
   for (const concern of concerns) {
     const concern_started = _now_iso();
     const { rc: rawRcResult, stderr: stderr_text, stdout: stdout_text, duration_ms } =
@@ -804,6 +811,14 @@ export function main(argv?: string[]): number {
     }
     rcs.push(rc);
     const reply = _parse_concern_stdout(stdout_text);
+    if (
+      args.event === "session_start" &&
+      rc === EXIT_ALLOW &&
+      typeof reply["context"] === "string" &&
+      (reply["context"] as string).trim()
+    ) {
+      context_blocks.push((reply["context"] as string).trim());
+    }
     feedback_entries.push({
       concern: String(concern["name"]),
       exit_code: rc,
@@ -819,6 +834,9 @@ export function main(argv?: string[]): number {
   }
   const final_rc = _reduce(rcs);
   _write_feedback(envelope, session_id, feedback_entries, final_rc, started_at);
+  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW) {
+    process.stdout.write(context_blocks.join("\n\n") + "\n");
+  }
   return final_rc;
 }