@event4u/agent-config 7.4.0 → 8.0.0

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: []
@@ -76,6 +88,17 @@ concerns:
     script: src/scripts/hooks/rtk_wrap_hook.ts
     args: []
     fail_closed: false
+  # road-to-anti-slop-detector Phase 3 — OPTIONAL PreToolUse anti-slop nudge.
+  # Runs the lint_design_slop registry against about-to-be-written UI content
+  # and WARNS (exit 2) on P0/P1 aesthetic tells. Never blocks (flags, not
+  # blocks). Default-OFF (hooks.design_slop.enabled). Anti-loop degradation: a
+  # file::rule signature surfaced >=3x goes silent so it never traps the agent.
+  # The universal source of truth is the lint_design_slop linter/CI; this hook
+  # is a host-limited convenience layer. fail_closed: false.
+  design-slop:
+    script: src/scripts/hooks/design_slop_hook.ts
+    args: []
+    fail_closed: false
   # Phase 2 of road-to-hooks-actually-fire-in-consumers — session_start
   # gate that surfaces the marketplace-install-but-unscaffolded shape.
   # Writes .augment/.first-run-action-needed.md + one stderr line so
@@ -105,18 +128,18 @@ 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]
-    pre_tool_use:     [block-no-verify, rtk-wrap]
+    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]
+    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]
 
   # Cowork — the Claude desktop app's local-agent-mode runtime, built
@@ -134,11 +157,11 @@ 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]
+    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]
 
   # Phase 7.5 — Cursor. `.cursor/hooks.json` (project) is read by the
@@ -149,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]
 
@@ -164,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]
 
@@ -183,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`
@@ -198,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/design_slop_hook.ts

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse anti-slop nudge — surfaces high-severity aesthetic tells in
+ * proposed UI content BEFORE the write (road-to-anti-slop-detector Phase 3).
+ *
+ * OPTIONAL, host-limited (pre_tool_use fires on ~2–3 hosts). The universal
+ * source of truth is the `lint_design_slop` linter / CI gate; this hook is a
+ * convenience layer that runs the same registry against the about-to-be-written
+ * content. Default-OFF: no-ops unless `hooks.design_slop.enabled: true` in
+ * `.agent-settings.yml`. fail_closed: false (never break a write for a flag).
+ *
+ * FLAGS, NEVER A BLOCK. On a P0/P1 finding it WARNS (exit 2 + reason); it never
+ * returns block (exit 1). Mirrors the injection-scan "warn, don't block" shape.
+ *
+ * Anti-loop degradation (council-required safety valve): a `file::rule`
+ * signature surfaced ≥ DEGRADE_AFTER times is downgraded to silent, so a
+ * deliberate-but-undeclared pattern the agent keeps re-writing never traps it.
+ * State: <root>/agents/runtime/state/design-slop-hook.json.
+ *
+ * Exit codes (dispatcher contract): 0 allow · 2 warn (+ JSON reason on stdout).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { type DesignContext } from "../design_slop_rules.js";
+import { loadDesignContext, scanFile } from "../lint_design_slop.js";
+
+const SETTINGS_FILE = ".agent-settings.yml";
+const EXIT_ALLOW = 0;
+const EXIT_WARN = 2;
+const DEGRADE_AFTER = 3; // surfaces of the same file::rule signature before going silent
+const UI_EXT = /\.(html|htm|css|scss|sass|less|vue|svelte|astro|jsx|tsx)$/i;
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [k: string]: JsonValue };
+type JsonObject = { [k: string]: JsonValue };
+
+function isObject(v: unknown): v is JsonObject {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/** Minimal `.agent-settings.yml` reader for hooks.design_slop.enabled (mirrors injection-scan). */
+function enabled(root: string): boolean {
+  const f = path.join(root, SETTINGS_FILE);
+  let text: string;
+  try {
+    if (!fs.statSync(f).isFile()) return false;
+    text = fs.readFileSync(f, "utf-8");
+  } catch {
+    return false;
+  }
+  let inHooks = false;
+  let inDs = false;
+  for (const raw of text.split(/\r\n|\r|\n/)) {
+    const line = raw.replace(/\s+$/, "");
+    if (!line || line.replace(/^\s+/, "").startsWith("#")) continue;
+    if (!(line.startsWith(" ") || line.startsWith("\t"))) {
+      inHooks = /^hooks\s*:\s*$/.test(line);
+      inDs = false;
+      continue;
+    }
+    if (inHooks) {
+      if (/^\s+design_slop\s*:\s*$/.test(line)) {
+        inDs = true;
+        continue;
+      }
+      if (inDs && /^\s{0,3}\S/.test(line)) inDs = false;
+    }
+    if (inDs && /^\s+enabled\s*:\s*true\b/.test(line)) return true;
+  }
+  return false;
+}
+
+/** Best-effort: pull (toolName, filePath, proposedContent) from the PreToolUse envelope. */
+function extract(envelope: JsonObject): { file: string; content: string } | null {
+  const ti = envelope["tool_input"] ?? envelope["toolInput"] ?? envelope["input"];
+  if (!isObject(ti)) return null;
+  const fileVal = ti["file_path"] ?? ti["path"] ?? ti["filePath"];
+  const file = typeof fileVal === "string" ? fileVal : "";
+  // Edit → new_string/new_str; Write → content; some hosts → text
+  for (const key of ["content", "new_string", "new_str", "text", "newText"]) {
+    const v = ti[key];
+    if (typeof v === "string" && v.length > 0) return { file, content: v };
+  }
+  return null;
+}
+
+function stateFile(root: string): string {
+  return path.join(root, "agents", "runtime", "state", "design-slop-hook.json");
+}
+
+function readState(root: string): Record<string, number> {
+  try {
+    const t = fs.readFileSync(stateFile(root), "utf-8");
+    const parsed = JSON.parse(t);
+    return isObject(parsed) ? (parsed as Record<string, number>) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeState(root: string, state: Record<string, number>): void {
+  try {
+    const sf = stateFile(root);
+    fs.mkdirSync(path.dirname(sf), { recursive: true });
+    fs.writeFileSync(sf, JSON.stringify(state, null, 2) + "\n");
+  } catch {
+    /* fail-open: never break a write because state could not persist */
+  }
+}
+
+function readStdin(): string {
+  try {
+    return fs.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export function main(): number {
+  let envelope: JsonValue;
+  try {
+    const raw = readStdin();
+    envelope = raw.trim() ? (JSON.parse(raw) as JsonValue) : {};
+  } catch {
+    return EXIT_ALLOW;
+  }
+  if (!isObject(envelope)) return EXIT_ALLOW;
+
+  const rootVal = envelope["cwd"] ?? envelope["project_root"] ?? ".";
+  const root = typeof rootVal === "string" && rootVal ? rootVal : ".";
+  if (!enabled(root)) return EXIT_ALLOW;
+
+  const ex = extract(envelope);
+  if (!ex || !ex.file || !UI_EXT.test(ex.file)) return EXIT_ALLOW;
+
+  let ctx: DesignContext;
+  try {
+    ctx = loadDesignContext(path.dirname(path.resolve(root, ex.file)));
+  } catch {
+    ctx = { raw: "", has: () => false };
+  }
+
+  let findings;
+  try {
+    findings = scanFile(ex.content, ex.file, ctx).filter(
+      (f) => f.severity === "P0" || f.severity === "P1",
+    );
+  } catch {
+    return EXIT_ALLOW;
+  }
+  if (findings.length === 0) return EXIT_ALLOW;
+
+  // Anti-loop degradation: drop any signature already surfaced DEGRADE_AFTER times.
+  const state = readState(root);
+  const surfaced = findings.filter((f) => {
+    const sig = `${ex.file}::${f.rule}`;
+    const seen = state[sig] ?? 0;
+    if (seen >= DEGRADE_AFTER) return false; // gone silent — never trap the agent
+    state[sig] = seen + 1;
+    return true;
+  });
+  writeState(root, state);
+
+  if (surfaced.length === 0) return EXIT_ALLOW;
+
+  const lines = surfaced
+    .map((f) => `${f.catalogId} (${f.rule}) ${f.file}:${f.line} — ${f.message}`)
+    .join("; ");
+  const reason =
+    "⚠️ Anti-slop: high-severity aesthetic tell(s) in the proposed UI — " +
+    lines +
+    ". Rebuttable: declare intent in DESIGN.md, add design-slop-disable-next-line, " +
+    "or proceed if deliberate (this is a flag, not a block).";
+  process.stdout.write(JSON.stringify({ decision: "warn", reason }) + "\n");
+  return EXIT_WARN;
+}
+
+const isCliEntry =
+  process.argv[1] !== undefined &&
+  import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (isCliEntry) process.exit(main());

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;
 }