@event4u/agent-config 16.3.0 → 16.5.0

package/src/scripts/command_suggester/settings.ts

@@ -1,16 +1,17 @@
 /**
- * Read `commands.suggestion.*` from `.agent-settings.yml` into `Settings`.
+ * Read `commands.suggestion.blocklist` from `.agent-settings.yml` into `Settings`.
  *
  * Ported from the retired Python `src/scripts/command_suggester/settings.py`
  * (ADR-200 py2ts). Mirror of the chat-history pattern:
  *
- *  - Default-permissive: a missing file or missing section returns
- *    `Settings()` defaults (suggestion layer enabled). Only an explicit
- *    `enabled: false` flips the master switch off.
+ *  - The blocklist is the only suggestion key a project still sets. The
+ *    master switch, floor, cooldown and option cap are engine constants in
+ *    `Settings`: their keys were retired with those defaults as the fixed
+ *    behavior, so a leftover value is warned about by the loader and never
+ *    read here.
  *  - Malformed YAML / unreadable file → defaults; the suggester degrades
  *    silently rather than crashing the turn.
- *  - Type-coerces with bounded fallbacks (floors clamped 0.0-1.0, ints
- *    non-negative, blocklist forced to an array of strings).
+ *  - The blocklist is forced to an array of non-empty strings.
  *
  * The Python module reads the YAML via the shared `agent_settings`
  * loader; this twin delegates to the ported `agent_settings.ts`.
@@ -61,54 +62,7 @@ function _read_section(path: string): Record<string, unknown> | null {
 }
 
 function _settings_from_raw(raw: Record<string, unknown>): Settings {
-    return new Settings({
-        enabled: _coerce_bool(raw.enabled, _DEFAULT.enabled),
-        confidence_floor: _coerce_floor(raw.confidence_floor, _DEFAULT.confidence_floor),
-        cooldown_seconds: _coerce_nonneg_int(raw.cooldown_seconds, _DEFAULT.cooldown_seconds),
-        max_options: _coerce_nonneg_int(raw.max_options, _DEFAULT.max_options),
-        blocklist: _coerce_str_tuple(raw.blocklist),
-    });
-}
-
-function _coerce_bool(value: unknown, defaultValue: boolean): boolean {
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    if (value === null || value === undefined) {
-        return defaultValue;
-    }
-    if (typeof value === 'string') {
-        const s = value.trim().toLowerCase();
-        if (['true', 'yes', 'on', '1'].includes(s)) {
-            return true;
-        }
-        if (['false', 'no', 'off', '0'].includes(s)) {
-            return false;
-        }
-    }
-    return defaultValue;
-}
-
-function _coerce_floor(value: unknown, defaultValue: number): number {
-    const f = _pyFloat(value);
-    if (f === null) {
-        return defaultValue;
-    }
-    if (f < 0.0) {
-        return 0.0;
-    }
-    if (f > 1.0) {
-        return 1.0;
-    }
-    return f;
-}
-
-function _coerce_nonneg_int(value: unknown, defaultValue: number): number {
-    const i = _pyInt(value);
-    if (i === null) {
-        return defaultValue;
-    }
-    return i >= 0 ? i : defaultValue;
+    return new Settings({ blocklist: _coerce_str_tuple(raw.blocklist) });
 }
 
 function _coerce_str_tuple(value: unknown): string[] {
@@ -127,60 +81,6 @@ function _coerce_str_tuple(value: unknown): string[] {
     return out;
 }
 
-/**
- * Mirror of Python `float(value)`, returning null where Python raises
- * `TypeError` / `ValueError` (the coercion catches those and falls
- * back to the default).
- */
-function _pyFloat(value: unknown): number | null {
-    if (typeof value === 'boolean') {
-        return value ? 1.0 : 0.0;
-    }
-    if (typeof value === 'number') {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const s = value.trim();
-        if (s === '') {
-            return null;
-        }
-        const n = Number(s);
-        return Number.isNaN(n) ? null : n;
-    }
-    return null;
-}
-
-/**
- * Mirror of Python `int(value)` for the YAML scalar types, returning
- * null where Python raises.
- *
- *  - bool → 1 / 0.
- *  - int  → itself.
- *  - float → truncated toward zero (Python `int(3.9) == 3`).
- *  - string → `int(str, 10)` semantics: an optional sign + digits,
- *    surrounding whitespace allowed; a float-shaped string raises in
- *    Python, so it maps to null.
- */
-function _pyInt(value: unknown): number | null {
-    if (typeof value === 'boolean') {
-        return value ? 1 : 0;
-    }
-    if (typeof value === 'number') {
-        if (Number.isNaN(value) || !Number.isFinite(value)) {
-            return null;
-        }
-        return Math.trunc(value);
-    }
-    if (typeof value === 'string') {
-        const s = value.trim();
-        if (!/^[+-]?\d+$/.test(s)) {
-            return null;
-        }
-        return parseInt(s, 10);
-    }
-    return null;
-}
-
 function _isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/src/scripts/command_suggester/types.ts

@@ -98,11 +98,10 @@ export class Match {
 }
 
 /**
- * Runtime knobs read from `.agent-settings.yml`.
- *
- * Defaults match the "open decisions" leans in the roadmap.
- * Per-command frontmatter values override the global floor /
- * cooldown.
+ * Engine knobs. Only `blocklist` comes from `.agent-settings.yml`; the
+ * other four are fixed defaults (their settings keys were retired), still
+ * overridable by a caller that constructs `Settings` directly.
+ * Per-command frontmatter values override the floor / cooldown.
  *
  * Mirrors `@dataclass(frozen=True)`. The Python default `blocklist`
  * is an empty tuple; here it is a readonly string array, canonicalized

package/src/scripts/consumer_matrix.ts

@@ -515,6 +515,107 @@ function legProjections(ctx: Ctx): string {
     return 'cursor + windsurf + claude projection trees present in global scope';
 }
 
+// ── git-convention leg ─────────────────────────────────────────────
+//
+// A consumer project has neither `scripts-run` nor `node_modules`, so the only
+// code an installed command can reach is the `agent-config` binary. `/pr:merge`
+// reads the update strategy through `git:convention show`; this leg runs that
+// verb from the packed install in a repository that commits a
+// `.git-convention.yml` and pushes it to an `origin`, so the strategy resolves
+// at a real target commit.
+
+const GIT_CONVENTION_CARRIER = 'git:\n  commit_format: ticket-conventional\n  update_strategy: rebase\n';
+
+/** The verdict on `git:convention show --json`; throws with the reason on any miss. */
+export function checkGitConventionShow(status: number, stdout: string, stderr = ''): string {
+    if (status !== 0) throw new Error(`git:convention show exit ${status}: ${(stdout + stderr).slice(-400)}`);
+    let parsed: { keys?: Record<string, { value?: unknown; state?: unknown; source?: unknown }> };
+    try {
+        parsed = JSON.parse(stdout) as typeof parsed;
+    } catch {
+        throw new Error(`git:convention show --json printed output that is not JSON: ${stdout.slice(0, 200)}`);
+    }
+    const expected: Record<string, string> = { commit_format: 'ticket-conventional', update_strategy: 'rebase' };
+    for (const [key, value] of Object.entries(expected)) {
+        const r = parsed.keys?.[key];
+        const fromCarrier = typeof r?.source === 'string' && r.source.includes('.git-convention.yml');
+        if (r?.value !== value || r.state !== 'valid' || !fromCarrier) {
+            throw new Error(`git.${key} did not resolve from the committed carrier: ${JSON.stringify(r ?? null)}`);
+        }
+    }
+    return 'commit_format=ticket-conventional, update_strategy=rebase, both from the committed .git-convention.yml';
+}
+
+/**
+ * The verdict on `git:convention subject` from the packed install: a valid
+ * subject resolves (exit 0), and a ticket inside a compound scope is rejected
+ * (exit 1) under the committed `ticket-conventional`.
+ */
+export function checkGitConventionSubject(
+    valid: { status: number; stdout: string; stderr?: string },
+    compound: { status: number; stdout: string; stderr?: string },
+): string {
+    if (valid.status !== 0) {
+        throw new Error(`git:convention subject rejected a valid subject, exit ${valid.status}: ${(valid.stdout + (valid.stderr ?? '')).slice(-400)}`);
+    }
+    if (compound.status !== 1 || !compound.stdout.includes('inside the scope')) {
+        throw new Error(`git:convention subject did not reject a ticket inside a compound scope, exit ${compound.status}: ${compound.stdout.slice(-400)}`);
+    }
+    return 'a valid subject resolves; a ticket inside a compound scope is rejected';
+}
+
+/**
+ * The verdict on `git:convention sync` from the packed install: the update
+ * `/pr:merge` § 2 runs. A current branch exits 0; a behind one is refused with
+ * exit 3 under the committed `rebase`, never merged.
+ */
+export function checkGitConventionSync(
+    current: { status: number; stdout: string; stderr?: string },
+    behind: { status: number; stdout: string; stderr?: string },
+): string {
+    if (current.status !== 0) {
+        throw new Error(`git:convention sync did not pass a current branch, exit ${current.status}: ${(current.stdout + (current.stderr ?? '')).slice(-400)}`);
+    }
+    if (behind.status !== 3 || !behind.stdout.includes('git.update_strategy is `rebase`')) {
+        throw new Error(`git:convention sync did not refuse a behind branch under rebase, exit ${behind.status}: ${behind.stdout.slice(-400)}`);
+    }
+    return 'sync passes a current branch and refuses a behind one with exit 3';
+}
+
+function legGitConvention(ctx: Ctx): string {
+    const env = binEnv(ctx);
+    const remote = path.join(ctx.tmpRoot, 'git-convention-origin.git');
+    const repo = path.join(ctx.tmpRoot, 'git-convention-project');
+    const git = (cwd: string, ...args: string[]): void => {
+        const r = run('git', ['-c', 'user.name=matrix', '-c', 'user.email=matrix@example.com', '-c', 'commit.gpgsign=false', ...args], {
+            cwd,
+            env,
+        });
+        if (r.status !== 0) throw new Error(`git ${args[0] ?? ''} failed: ${r.stderr.slice(-300)}`);
+    };
+    git(ctx.tmpRoot, 'init', '-q', '--bare', '-b', 'main', remote);
+    git(ctx.tmpRoot, 'init', '-q', '-b', 'main', repo);
+    fs.writeFileSync(path.join(repo, '.git-convention.yml'), GIT_CONVENTION_CARRIER);
+    git(repo, 'add', '.git-convention.yml');
+    git(repo, 'commit', '-q', '-m', 'declare the git convention');
+    git(repo, 'remote', 'add', 'origin', remote);
+    git(repo, 'push', '-q', '-u', 'origin', 'main');
+    const r = run(ctx.bin, ['git:convention', 'show', '--json', '--base', 'origin/main'], { cwd: repo, env });
+    const shown = checkGitConventionShow(r.status, r.stdout, r.stderr);
+    const subject = (line: string) => run(ctx.bin, ['git:convention', 'subject'], { cwd: repo, env, input: `${line}\n` });
+    const subjects = checkGitConventionSubject(subject('DEV-1 feat(api): add x'), subject('DEV-1 feat(api,DEV-1): add x'));
+    const sync = () => run(ctx.bin, ['git:convention', 'sync', '--base', 'origin/main'], { cwd: repo, env });
+    git(repo, 'switch', '-q', '-c', 'feature');
+    const current = sync();
+    git(repo, 'switch', '-q', 'main');
+    fs.writeFileSync(path.join(repo, 'advance.txt'), 'advance\n');
+    git(repo, 'add', 'advance.txt');
+    git(repo, 'commit', '-q', '-m', 'advance main');
+    git(repo, 'push', '-q', 'origin', 'main');
+    git(repo, 'switch', '-q', 'feature');
+    return `${shown}; ${subjects}; ${checkGitConventionSync(current, sync())}`;
+}
+
 function legUninstall(ctx: Ctx): string {
     const r = run(ctx.bin, ['uninstall', '--global', '--tools=claude-code,cursor,windsurf', '--force'], {
         cwd: ctx.projectDir,
@@ -570,6 +671,7 @@ const LEGS: Array<{ name: string; fn: (ctx: Ctx) => string | Promise<string> }>
     { name: 'hooks', fn: legHooks },
     { name: 'hook-lifecycle', fn: legHookLifecycle },
     { name: 'projections', fn: legProjections },
+    { name: 'git-convention', fn: legGitConvention },
     { name: 'uninstall', fn: legUninstall },
     { name: 'upgrade', fn: legUpgrade },
 ];

package/src/scripts/context_hygiene_hook.ts

@@ -7,21 +7,25 @@
  * module exactly (snake_case kept deliberately — fidelity over TS idiom).
  *
  * Maintains a deterministic state file the rule body cites for the
- * freshness threshold, the 3-failure stop, and tool-loop detection. The
- * agent's job shrinks from "remember three counters" to "read this file
- * before responding".
+ * freshness threshold and the 3-failure stop. The agent's job shrinks from
+ * "remember counters" to "read this file before responding".
  *
  * Output: `agents/state/context-hygiene.json`
  *   {
  *     "tool_calls": <int>,                 // running PostToolUse count
- *     "consecutive_same_tool": <int>,      // includes the latest call
- *     "last_tool": "<name>",
  *     "tool_history": [..., last 5 names],
- *     "loop_detected": <bool>,             // ≥ 3 same tool in a row
  *     "freshness_threshold": <int|null>,   // 20/40/60 milestone hit
  *     "checked_at": "<iso8601>"
  *   }
  *
+ * No same-tool-repeat ("loop") field: a same-tool-name counter fires on
+ * ordinary, non-looping work (an enumerated sweep over distinct targets
+ * calls the same tool repeatedly by design — the rule's own text says
+ * "'similar parameters' is the load-bearing word"), reaches no model (its
+ * only emission was a verbose stderr line), and had two readers, one of
+ * which read a path nothing wrote. Removed rather than repaired —
+ * road-to-signals-that-mean-what-they-say D1.
+ *
  * Exit code is always 0.
  *
  * CLI:
@@ -33,8 +37,9 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // Re-use the shared atomic-write helper so concerns honour the single
-// `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
-// § Concurrency, Phase 7.4).
+// `agents/state/.dispatcher.lock` discipline (hook-architecture-v1.md,
+// Concurrency, Phase 7.4) — the lock sits beside THIS hook's own target, not
+// the fixed `agents/runtime/state/` path the discipline cites generally.
 import { atomic_write_json } from "./hooks/state_io.js";
 import { readHookStdin } from "./hooks/hook_stdin.js";
 
@@ -45,7 +50,6 @@ import { readHookStdin } from "./hooks/hook_stdin.js";
 export const STATE_DIR = path.join("agents", "state");
 export const STATE_FILE = path.join(STATE_DIR, "context-hygiene.json");
 
-export const LOOP_THRESHOLD = 3; // 3+ consecutive same-tool calls
 export const HISTORY_DEPTH = 5;
 export const FRESHNESS_MILESTONES = [20, 40, 60] as const;
 
@@ -56,10 +60,7 @@ type StateDict = Record<string, unknown>;
 function _empty_state(): StateDict {
   return {
     tool_calls: 0,
-    consecutive_same_tool: 0,
-    last_tool: null,
     tool_history: [],
-    loop_detected: false,
     freshness_threshold: null,
   };
 }
@@ -134,14 +135,6 @@ function _update(state: StateDict, tool: string | null): StateDict {
   const curr_count = prev_count + 1;
   state["tool_calls"] = curr_count;
 
-  const last = state["last_tool"];
-  if (last === tool) {
-    state["consecutive_same_tool"] = _asInt(state["consecutive_same_tool"]) + 1;
-  } else {
-    state["consecutive_same_tool"] = 1;
-  }
-  state["last_tool"] = tool;
-
   let hist = state["tool_history"];
   if (!Array.isArray(hist)) {
     hist = [];
@@ -149,8 +142,6 @@ function _update(state: StateDict, tool: string | null): StateDict {
   (hist as unknown[]).push(tool);
   state["tool_history"] = (hist as unknown[]).slice(-HISTORY_DEPTH);
 
-  state["loop_detected"] = _asInt(state["consecutive_same_tool"]) >= LOOP_THRESHOLD;
-
   const ms = _milestone_hit(prev_count, curr_count);
   if (ms !== null) {
     state["freshness_threshold"] = ms;
@@ -211,7 +202,6 @@ export function run(
   if (verbose) {
     process.stderr.write(
       `context-hygiene-hook: tool_calls=${pyRepr(state["tool_calls"])} ` +
-        `loop=${pyRepr(state["loop_detected"])} ` +
         `threshold=${pyRepr(state["freshness_threshold"])}\n`,
     );
   }

package/src/scripts/cost/preflight.mjs

@@ -11,12 +11,23 @@
 // turn: `task cost:preflight` or `node scripts/cost/preflight.mjs`.
 
 import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 
 const QUIET = process.env.PREFLIGHT_QUIET === '1';
 
+// budget.mjs is this file's SIBLING, so resolve it from here rather than from
+// the working directory. A cwd-relative 'scripts/cost/budget.mjs' resolved to
+// nothing in this tree (the scripts live under src/scripts/), spawnSync
+// returned empty stdout, and empty stdout is read below as "no budget
+// configured" — so the hard stop silently exited 0 on a spent budget from
+// every working directory. Sibling resolution also survives the consumer
+// install, where the pair lands under a different prefix together.
+const BUDGET_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'budget.mjs');
+
 function runBudgetCheck() {
   const env = { ...process.env, BUDGET_QUIET: '1' };
-  const r = spawnSync('node', ['scripts/cost/budget.mjs', 'check'], { env, encoding: 'utf-8' });
+  const r = spawnSync('node', [BUDGET_SCRIPT, 'check'], { env, encoding: 'utf-8' });
   if (r.error) return { ok: false, fatal: true, msg: String(r.error) };
   const out = (r.stdout || '').trim();
   if (!out) return { ok: true, unbudgeted: true };

package/src/scripts/council_cli.ts

@@ -2127,7 +2127,7 @@ function _ljust(s: string, width: number): string {
 
 function _debate_refusal_cap(ai_cfg: Dict): number {
     const debate_block = (ai_cfg['debate'] as Dict) || {};
-    return _pyFloat(debate_block['max_cost_usd'] ?? 5.0, 5.0) || 0.0;
+    return _pyFloat(debate_block['max_cost_usd'] ?? 0.0, 0.0) || 0.0; // 0 = no cap (ADR-279)
 }
 
 function _emit_shadow_slo_banner(): void {
@@ -2560,9 +2560,9 @@ function cmd_run(
 
     const cost_cfg = (ai_cfg['cost_budget'] as Dict) || {};
     const budget = new CostBudget({
-        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 50_000, 50_000),
-        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 20_000, 20_000),
-        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10),
+        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10), // a call count, not money — kept
         max_total_usd: _pyFloat(cost_cfg['max_total_usd'] ?? 0.0, 0.0) || 0.0,
         // Rolling 24h cap. Unwired until now: the field existed on CostBudget and
         // gated the spend-ledger append, but no caller ever passed it, so the
@@ -3076,9 +3076,9 @@ function cmd_debate(
 
     const cost_cfg = (ai_cfg['cost_budget'] as Dict) || {};
     const budget = new CostBudget({
-        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 50_000, 50_000),
-        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 20_000, 20_000),
-        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10),
+        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10), // a call count, not money — kept
         max_total_usd: _pyFloat(cost_cfg['max_total_usd'] ?? 0.0, 0.0) || 0.0,
         // Rolling 24h cap. Unwired until now: the field existed on CostBudget and
         // gated the spend-ledger append, but no caller ever passed it, so the

package/src/scripts/dispatch_r2_reviewer.ts

@@ -738,6 +738,29 @@ export const RETURN_ENVELOPE_POINTER =
     'write-to-disk-first rule: contexts/execution/subagent-response-contract.md. ' +
     'The findings table stays a file.';
 
+/**
+ * Two-line header prepended, verbatim and at byte offset 0, to every
+ * `<slug>.review-input/roadmap.md` snapshot this dispatcher writes.
+ *
+ * Its NAMED job is `check_references`'s file-level skip marker
+ * (`check_references.ts` `FILE_SKIP_MARKER`): the snapshot sits under a
+ * tree that gate walks, while the LIVE roadmap layer is deliberately
+ * excluded from it — so a roadmap that legitimately quotes a nonexistent
+ * path (e.g. documenting a hallucinated council citation) would red CI
+ * through its own review snapshot.
+ *
+ * That is its only job. It used to carry a second, unnamed one — pushing the
+ * frontmatter fence off byte offset 0 kept `check_agent_artifact_location`
+ * from reading the snapshot as a misplaced roadmap. That gate now exempts the
+ * snapshot path by name (`isReviewInputRoadmapSnapshot`), so this header may
+ * change without that gate noticing. Tested in
+ * `check_agent_artifact_location.test.ts` (describe: "review-input snapshot
+ * convention").
+ */
+export const REVIEW_INPUT_ROADMAP_HEADER =
+    '<!-- check-refs: skip -->\n' +
+    '<!-- verbatim roadmap snapshot for the R2 reviewer; the live roadmap layer is excluded from check_references, and a snapshot must not fail a gate its source is exempt from -->\n';
+
 function reviewerPrompt(args: {
     slug: string;
     headSha: string;
@@ -1288,19 +1311,9 @@ function runDispatch(args: Args): number {
 
     redactions += writeRedacted(path.join(inputDirAbs, 'diff.patch'), scopeDiffText, denyPatterns);
     if (roadmapText !== null) {
-        // The snapshot lands under agents/evidence/, which check_references
-        // walks, while the live roadmap layer is deliberately excluded from
-        // that gate — so a roadmap that legitimately quotes a nonexistent
-        // path (e.g. documenting a hallucinated council citation) would red
-        // CI through its own review snapshot. The header exemption keeps the
-        // snapshot verbatim below the marker; roadmap_hash binds the LIVE
-        // file and is unaffected. Found by the zcs-close CI run, 2026-08-09.
-        const snapshotHeader =
-            '<!-- check-refs: skip -->\n' +
-            '<!-- verbatim roadmap snapshot for the R2 reviewer; the live roadmap layer is excluded from check_references, and a snapshot must not fail a gate its source is exempt from -->\n';
         redactions += writeRedacted(
             path.join(inputDirAbs, 'roadmap.md'),
-            snapshotHeader + roadmapText,
+            REVIEW_INPUT_ROADMAP_HEADER + roadmapText,
             denyPatterns,
         );
     }

package/src/scripts/explain_run.ts

@@ -27,7 +27,7 @@
  *      honest "no telemetry record" line, never a fabricated estimate.
  *      Sources: `_lib/judgment_ladder.ts::explainLadder` + the same
  *      audit-log-v1 files as §4.
- *   5. Hook / loop / freshness state snapshot. Source:
+ *   5. Hook / freshness state snapshot. Source:
  *      `agents/state/context-hygiene.json` (the code path the hook
  *      actually writes — see `context_hygiene_hook.ts::STATE_FILE`) or
  *      the doc-referenced `agents/runtime/state/context-hygiene.json`.
@@ -477,7 +477,7 @@ function renderSummarySection(
         out.push('- Session health: no state recorded.');
     } else {
         const s = hygiene.state;
-        out.push(`- Session health: ${String(s['tool_calls'] ?? '(unset)')} tool call(s) recorded, loop detected: ${String(s['loop_detected'] ?? '(unset)')}.`);
+        out.push(`- Session health: ${String(s['tool_calls'] ?? '(unset)')} tool call(s) recorded.`);
     }
     return out;
 }
@@ -686,7 +686,7 @@ function renderDecisionSection(
 
 function renderHygieneSection(hygiene: HygieneReadResult): string[] {
     const out: string[] = [];
-    out.push('## Hook / loop state (context-hygiene)');
+    out.push('## Hook state (context-hygiene)');
     out.push(`_Source: tried ${hygiene.checkedPaths.map((p) => `\`${p}\``).join(', then ')}_`);
     out.push('');
     if (hygiene.state === null) {
@@ -697,9 +697,6 @@ function renderHygieneSection(hygiene: HygieneReadResult): string[] {
     out.push(`Found at \`${hygiene.path}\`.`);
     out.push('');
     out.push(`- tool_calls: ${String(s['tool_calls'] ?? '(unset)')}`);
-    out.push(`- consecutive_same_tool: ${String(s['consecutive_same_tool'] ?? '(unset)')}`);
-    out.push(`- last_tool: ${String(s['last_tool'] ?? '(unset)')}`);
-    out.push(`- loop_detected: ${String(s['loop_detected'] ?? '(unset)')}`);
     out.push(`- freshness_threshold: ${String(s['freshness_threshold'] ?? '(unset)')}`);
     out.push(`- checked_at: ${String(s['checked_at'] ?? '(unset)')}`);
     return out;
@@ -718,14 +715,12 @@ function renderParkedSection(): string[] {
         '   thin-projector budget decision** — no on-disk record of "artefact',
         '   considered but dropped for budget" exists today. Revisit-if such a',
         '   record ships.',
-        '3. **Which memory entry id influenced a specific answer**, when the run',
-        '   did NOT opt into `decision_engine.surface_traces` — the',
+        '3. **Which memory entry id influenced a specific answer** — the',
         '   `🧠 Memory: n/m · ids=[...]` line is printed to stdout only, never',
-        '   persisted. The durable form (`memory.ids` in',
-        '   `agents/runtime/state/work/<id>/decision-trace-<phase>.json`) exists',
-        '   ONLY when `decision_engine.surface_traces: true` (off by default) and',
-        '   the run went through /work or /implement-ticket — see `explain last`',
-        '   for that narrower, per-run case; not duplicated here.',
+        '   persisted. The per-phase decision-trace file that once carried',
+        '   `memory.ids` is no longer written: its opt-in key,',
+        '   `decision_engine.surface_traces`, was retired (2026-10-09) with its',
+        '   default (off) as the fixed behavior.',
         '4. **Why a given subagent primitive was/wasn\'t available on this host**',
         '   — the host-capability manifest is resolved in-session by the agent',
         '   from its own knowledge (+ an optional settings override) and is never',