@event4u/agent-config 9.16.0 → 9.18.0

package/src/scripts/router_telemetry.ts

@@ -17,15 +17,10 @@
  * - tier_1 + tier_2 rules: active iff any trigger matches the prompt
  *   text (plus optional open-files / command context).
  *
- * Trigger semantics implemented:
- *
- *   | Type           | Match rule                                                       |
- *   |----------------|------------------------------------------------------------------|
- *   | `keyword`      | case-insensitive substring inside the prompt text                |
- *   | `phrase`       | case-insensitive substring (multi-word) inside the prompt text   |
- *   | `command`      | case-sensitive prefix on `command:` field (optional context)     |
- *   | `path_prefix`  | prefix match against any path in `open_files` (optional context) |
- *   | `file_pattern` | fnmatch against any path in `open_files` (optional context)      |
+ * Trigger semantics live in `_lib/router_match.ts` — the single matcher
+ * implementation (anchored `keyword`, unanchored `phrase`, `command`
+ * prefix, `path_prefix` / `file_pattern` over `open_files`); this module
+ * re-exports its names for existing importers.
  *
  * Reports go to `internal/bench/reports/router-telemetry/<UTC>.json`.
  *
@@ -36,6 +31,18 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseYaml, YAMLError } from "yaml";
 
+import {
+  _asRuleList,
+  keyword_matches_anchored,
+  match_prompt,
+  trigger_matches,
+} from "./_lib/router_match.js";
+import type { JsonValue, Router } from "./_lib/router_match.js";
+
+// The matcher lives in `_lib/router_match.ts` (the single implementation —
+// see its header). Re-exported here so existing importers keep working.
+export { keyword_matches_anchored, match_prompt, trigger_matches };
+
 // src/scripts/router_telemetry.ts → two levels up is the repo root
 // (mirrors the Python module's parent.parent.parent resolution from
 // src/scripts/router_telemetry.py).
@@ -58,29 +65,6 @@ const DEFAULT_SAMPLE_CAP = 200;
 // tasks are the attribution map and become the untouchable set.
 const TRACK_B_CORPUS_REL = "internal/bench/corpora/ab-trackb.yaml";
 
-type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonValue[]
-  | { [key: string]: JsonValue };
-
-type Trigger = Record<string, JsonValue>;
-
-interface Rule {
-  id?: JsonValue;
-  triggers?: JsonValue;
-  [key: string]: JsonValue;
-}
-
-interface Router {
-  kernel?: JsonValue;
-  tier_1?: JsonValue;
-  tier_2?: JsonValue;
-  [key: string]: JsonValue;
-}
-
 function _log(msg: string, quiet: boolean, err = false): void {
   if (err) {
     process.stderr.write(`${msg}\n`);
@@ -101,264 +85,6 @@ function _utc_iso(): string {
   return iso.slice(0, 19) + "+00:00";
 }
 
-// ── fnmatch (Python fnmatch.fnmatch) ─────────────────────────────────────
-
-/**
- * Translate a Unix shell pattern into a RegExp, matching CPython's
- * `fnmatch.translate`. `*` → `.*`, `?` → `.`, `[...]` char classes
- * preserved (with `!` → `^` negation), everything else escaped.
- * Matching is case-sensitive on POSIX (the corpus paths are POSIX).
- */
-function _fnmatchToRegExp(pat: string): RegExp {
-  let res = "";
-  let i = 0;
-  const n = pat.length;
-  while (i < n) {
-    const c = pat[i] as string;
-    i += 1;
-    if (c === "*") {
-      res += ".*";
-    } else if (c === "?") {
-      res += ".";
-    } else if (c === "[") {
-      let j = i;
-      if (j < n && pat[j] === "!") {
-        j += 1;
-      }
-      if (j < n && pat[j] === "]") {
-        j += 1;
-      }
-      while (j < n && pat[j] !== "]") {
-        j += 1;
-      }
-      if (j >= n) {
-        res += "\\[";
-      } else {
-        let stuff = pat.slice(i, j);
-        if (!stuff.includes("-")) {
-          stuff = stuff.replace(/\\/g, "\\\\");
-        } else {
-          // Faithful port of CPython's dash-handling in fnmatch.translate:
-          // split the class body on `-` (bounded to [i, j)), escaping each
-          // chunk, then re-join with `-` so ranges survive.
-          const chunks: string[] = [];
-          let k = pat[i] === "!" ? i + 2 : i + 1;
-          let start = i;
-          while (true) {
-            const rel = pat.slice(k, j).indexOf("-");
-            if (rel < 0) {
-              break;
-            }
-            const idx = k + rel;
-            chunks.push(pat.slice(start, idx));
-            start = idx + 1;
-            k = idx + 3;
-          }
-          chunks.push(pat.slice(start, j));
-          stuff = chunks
-            .map((s) => s.replace(/\\/g, "\\\\").replace(/-/g, "\\-"))
-            .join("-");
-        }
-        // Escape regex set-meta chars except backslash/dash already handled.
-        stuff = stuff.replace(/([&~|])/g, "\\$1");
-        i = j + 1;
-        if (stuff.startsWith("!")) {
-          stuff = "^" + stuff.slice(1);
-        } else if (stuff.startsWith("^") || stuff.startsWith("[")) {
-          stuff = "\\" + stuff;
-        }
-        res += `[${stuff}]`;
-      }
-    } else {
-      res += c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-  }
-  return new RegExp(`^(?:${res})$`, "s");
-}
-
-function _fnmatch(name: string, pat: string): boolean {
-  return _fnmatchToRegExp(pat).test(name);
-}
-
-// ── Trigger matching ─────────────────────────────────────────────────────
-
-/** Apply one trigger to a prompt + context; return True on match. */
-/** Unicode word character — letters, digits, underscore (incl. umlauts). */
-const _WORD_CHAR = /[\p{L}\p{N}_]/u;
-
-function _isWordChar(c: string | undefined): boolean {
-  return c !== undefined && _WORD_CHAR.test(c);
-}
-
-/**
- * Word-boundary-anchored keyword match (road-to-tested-routing Phase 3).
- *
- * A `keyword` occurrence counts only when its word-character edges sit on
- * word boundaries: `ac` no longer fires inside "black", `plan` no longer
- * fires inside "planet". Two deliberate reliefs:
- *
- * - An edge that is itself a NON-word character (e.g. `__()`, `/image:`,
- *   `trans(`, an emoji) carries no boundary requirement on that side —
- *   punctuation-shaped keywords keep their exact substring semantics.
- * - The right boundary accepts one optional plural `s` ("icons", "options",
- *   "secrets" still fire their singular keyword). Richer inflection (German
- *   verb endings: "implementiere", "committen") is a DOCUMENTED accepted
- *   recall cost of anchoring — the matrices carry standalone-token phrasings
- *   for those languages instead.
- *
- * `phrase` deliberately stays unanchored substring; since this change the
- * two trigger kinds genuinely differ.
- */
-export function keyword_matches_anchored(prompt_lower: string, kw_lower: string): boolean {
-  if (kw_lower === "") {
-    return false;
-  }
-  const needLeft = _isWordChar(kw_lower[0]);
-  const needRight = _isWordChar(kw_lower[kw_lower.length - 1]);
-  let idx = prompt_lower.indexOf(kw_lower);
-  while (idx !== -1) {
-    const leftOk = !needLeft || !_isWordChar(prompt_lower[idx - 1]);
-    let rightOk = true;
-    if (needRight) {
-      let end = idx + kw_lower.length;
-      if (prompt_lower[end] === "s") {
-        end += 1; // optional plural `s`
-      }
-      rightOk = !_isWordChar(prompt_lower[end]);
-    }
-    if (leftOk && rightOk) {
-      return true;
-    }
-    idx = prompt_lower.indexOf(kw_lower, idx + 1);
-  }
-  return false;
-}
-
-export function trigger_matches(
-  trigger: Trigger,
-  prompt: string,
-  open_files?: Iterable<string> | null,
-  command?: string | null,
-): boolean {
-  const prompt_lower = prompt.toLowerCase();
-  if ("keyword" in trigger) {
-    return keyword_matches_anchored(prompt_lower, String(trigger["keyword"]).toLowerCase());
-  }
-  if ("phrase" in trigger) {
-    return prompt_lower.includes(String(trigger["phrase"]).toLowerCase());
-  }
-  if ("command" in trigger) {
-    if (!command) {
-      return false;
-    }
-    return command.startsWith(String(trigger["command"]));
-  }
-  if ("path_prefix" in trigger) {
-    if (!open_files) {
-      return false;
-    }
-    const pref = String(trigger["path_prefix"]);
-    for (const p of open_files) {
-      if (String(p).startsWith(pref)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  if ("file_pattern" in trigger) {
-    if (!open_files) {
-      return false;
-    }
-    const pat = String(trigger["file_pattern"]);
-    for (const p of open_files) {
-      if (_fnmatch(String(p), pat)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return false;
-}
-
-interface MatchedTrigger {
-  tier: string;
-  rule: JsonValue | undefined;
-  trigger: Trigger;
-}
-
-interface ActivatedRule {
-  tier: string;
-  rule: JsonValue | undefined;
-}
-
-interface MatchResult {
-  matched_triggers: MatchedTrigger[];
-  activated_rules: ActivatedRule[];
-}
-
-function _asRuleList(value: JsonValue | undefined): Rule[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value as unknown as Rule[];
-}
-
-function _asTriggerList(value: JsonValue | undefined): Trigger[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value as unknown as Trigger[];
-}
-
-/**
- * Return the matched-triggers + activated-rules for one prompt.
- *
- * Kernel rules are always active. tier_1 always considered. tier_2
- * only considered when `profile == 'full'`.
- */
-export function match_prompt(
-  router: Router,
-  prompt: string,
-  profile = "full",
-  open_files?: Iterable<string> | null,
-  command?: string | null,
-): MatchResult {
-  const tiers: Array<[string, Rule[]]> = [
-    ["tier_1", _asRuleList(router["tier_1"])],
-  ];
-  if (profile === "full") {
-    tiers.push(["tier_2", _asRuleList(router["tier_2"])]);
-  }
-
-  const matched_triggers: MatchedTrigger[] = [];
-  const activated_rules: ActivatedRule[] = [];
-
-  for (const [tier_name, rules] of tiers) {
-    for (const rule of rules) {
-      const rule_id = rule["id"];
-      const rule_triggers = _asTriggerList(rule["triggers"]);
-      let rule_hit = false;
-      for (const trig of rule_triggers) {
-        if (trigger_matches(trig, prompt, open_files, command)) {
-          matched_triggers.push({ tier: tier_name, rule: rule_id, trigger: trig });
-          rule_hit = true;
-        }
-      }
-      if (rule_hit) {
-        activated_rules.push({ tier: tier_name, rule: rule_id });
-      }
-    }
-  }
-
-  // Kernel rules are always active.
-  const kernel = Array.isArray(router["kernel"]) ? router["kernel"] : [];
-  for (const kid of kernel) {
-    activated_rules.push({ tier: "kernel", rule: kid });
-  }
-
-  return { matched_triggers, activated_rules };
-}
-
 // ── JSON serialization (Python-faithful) ─────────────────────────────────
 
 /**

package/src/scripts/schemas/command.schema.json

@@ -128,6 +128,39 @@
       "enum": ["deep"],
       "description": "Optional reasoning-depth marker for AI Council invocations triggered by this command. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for architecture, refactoring, or bug-diagnosis commands. See .agent-src.uncondensed/skills/ai-council/SKILL.md."
     },
+    "limits": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["mode_default", "max_iterations", "hard_ceiling", "no_gain_stop", "target_metric"],
+      "description": "Machine-readable execution limits for autonomous-loop commands (release-truth Phase 4). The command body MUST restate each limit in its flow steps — frontmatter is the pin the deterministic test reads, the body is what the executing agent obeys.",
+      "properties": {
+        "mode_default": {
+          "type": "string",
+          "enum": ["plan", "execute"],
+          "description": "Default execution mode when the invocation names none. 'plan' = author and present, no push / PR / refinement loop."
+        },
+        "max_iterations": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Default refinement-loop budget."
+        },
+        "hard_ceiling": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Absolute loop ceiling — no flag may exceed it."
+        },
+        "no_gain_stop": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Consecutive loops without measurable gain on the pre-registered target metric that force a stop."
+        },
+        "target_metric": {
+          "type": "string",
+          "enum": ["required"],
+          "description": "A named target metric with a measured baseline must be recorded before loop 1."
+        }
+      }
+    },
     "model_tier": {
       "type": "string",
       "enum": ["lite", "medium", "high", "inherit"],

package/src/scripts/schemas/rule.schema.json

@@ -155,6 +155,16 @@
       },
       "description": "ADR-013 trust block. Vocabulary mirrored by scripts/lint_artefact_frontmatter.py."
     },
+    "collision_ok": {
+      "type": "object",
+      "additionalProperties": {"type": "string", "minLength": 8},
+      "description": "Per-trigger collision disposition: maps a trigger VALUE (case-insensitive) shared with >=1 other rule to a one-line reason why this rule also firing on it is correct. Enforced by scripts/lint_trigger_collisions.ts."
+    },
+    "precedence": {
+      "type": "object",
+      "additionalProperties": {"type": "integer"},
+      "description": "Alternative collision disposition: maps a shared trigger VALUE to an integer ordering; a collision is clean when ALL sharers declare pairwise-distinct integers for it. Enforced by scripts/lint_trigger_collisions.ts."
+    },
     "install": {
       "type": "object",
       "additionalProperties": false,

package/src/scripts/self_review_gate.ts

@@ -29,7 +29,8 @@
  * the `check_quality_regression.gateVerdict` pattern.
  */
 import { spawnSync } from 'node:child_process';
-import { appendFileSync, existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -50,6 +51,20 @@ export interface Finding {
     file?: string;
 }
 
+/**
+ * Stable identifier for a finding — sha256 of kind|title|file, 12 hex chars
+ * (release-truth Phase 3). The id keys the disposition ledger
+ * (`agents/evidence/release-findings/<version>.json`): the 9.14.0 symlink
+ * finding merged with no traceable disposition precisely because findings
+ * carried no identity that outlived the PR comment.
+ */
+export function findingId(f: Pick<Finding, 'kind' | 'title' | 'file'>): string {
+    return createHash('sha256')
+        .update(`${f.kind}|${f.title}|${f.file ?? ''}`)
+        .digest('hex')
+        .slice(0, 12);
+}
+
 /**
  * A finding is merge-blocking iff it is security- or claim-affecting AND at
  * least `high` severity. Style and correctness findings advise; low/medium
@@ -332,7 +347,7 @@ export function renderReview(findings: Finding[], enforce: boolean, escalation:
     const rows = findings
         .map((f) => {
             const marker = classifyBlocking(f) ? 'Blocking' : 'Advisory';
-            return `| ${f.severity} (${marker}) | ${f.kind} | ${f.file ?? '—'} | ${f.title} |`;
+            return `| ${findingId(f)} | ${f.severity} (${marker}) | ${f.kind} | ${f.file ?? '—'} | ${f.title} |`;
         })
         .join('\n');
     const verdictLine = blocking.length
@@ -340,7 +355,14 @@ export function renderReview(findings: Finding[], enforce: boolean, escalation:
             ? `❌ ${blocking.length} merge-blocking finding(s) (security/claim × high+).`
             : `⚠️ ${blocking.length} finding(s) WOULD block merge under an enforced gate (advisory now).`
         : '✅ No merge-blocking findings (style/correctness advise only).';
-    return `${banner}\n\n${verdictLine}\n\n| severity | kind | file | finding |\n|---|---|---|---|\n${rows}${esc}`;
+    // Machine-readable block (release-truth Phase 3): invisible in the rendered
+    // comment; `check_finding_dispositions --pr` reads it as the TRIGGER that
+    // demands committed dispositions. The comment is transport, never the
+    // record — the record is `agents/evidence/release-findings/<version>.json`.
+    const machine = `\n\n<!-- release-findings-json: ${JSON.stringify(
+        findings.map((f) => ({ finding_id: findingId(f), severity: f.severity, kind: f.kind, title: f.title, file: f.file ?? null })),
+    )} -->`;
+    return `${banner}\n\n${verdictLine}\n\n| id | severity | kind | file | finding |\n|---|---|---|---|---|\n${rows}${esc}${machine}`;
 }
 
 function postReview(body: string): void {
@@ -432,6 +454,22 @@ export function main(argv: string[]): 0 | 2 {
             return 0; // no credit / transport / API error → never blocks the merge
         }
         const findings = parseFindings(resp.text);
+        const outIdx = argv.indexOf('--findings-out');
+        if (outIdx >= 0 && argv[outIdx + 1]) {
+            // Durable ingestion input for the disposition ledger (release-truth
+            // Phase 3): `check_finding_dispositions --ingest <this file>`.
+            writeFileSync(
+                argv[outIdx + 1]!,
+                JSON.stringify(
+                    {
+                        schema_version: 1,
+                        findings: findings.map((f) => ({ finding_id: findingId(f), ...f })),
+                    },
+                    null,
+                    2,
+                ) + '\n',
+            );
+        }
         const body = renderReview(findings, enforce, plan.escalation);
         postReview(body);
 

package/src/scripts/skill_linter.ts

@@ -2554,7 +2554,9 @@ function lint_interaction_quality(p: string, text: string): Issue[] {
     ].some((kw) => textLower.includes(kw));
 
     if (hasQuestionContext) {
-        const hasSimple = ['simple', 'binary', 'independent'].some((kw) => textLower.includes(kw));
+        // 'decision point' is the ADR-214 cadence boundary ("one decision
+        // point = one question") that replaced the simple-vs-complex split.
+        const hasSimple = ['simple', 'binary', 'independent', 'decision point'].some((kw) => textLower.includes(kw));
         const hasComplex = ['complex', 'one at a time', 'one question'].some((kw) => textLower.includes(kw));
         if (!(hasSimple && hasComplex)) {
             issues.push(

package/src/scripts/smoke/router.sh

@@ -15,7 +15,7 @@
 
 set -euo pipefail
 
-EXPECTED_TOTAL_IDS=68
+EXPECTED_TOTAL_IDS=106
 EXPECTED_MISSING_CONTRACTS=2
 
 quiet="${SMOKE_QUIET:-0}"

package/src/scripts/update_counts.ts

@@ -34,25 +34,73 @@ const _HERE = fileURLToPath(import.meta.url);
 // REPO_ROOT = <file>.parent.parent.parent — two dirs up from src/scripts.
 export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 
-/** Recursively walk a directory, yielding files whose basename matches. */
+/**
+ * Recursively walk a directory, yielding files whose basename matches.
+ *
+ * Symlink confinement (release-truth Phase 3): a symlink — leaf or directory —
+ * is honored only when its target resolves inside the walk root; external
+ * targets, broken links, and cycles are ignored. Directory symlinks are
+ * followed through a visited-realpath set so a self-referential link
+ * terminates instead of recursing to stack exhaustion.
+ */
 function* _rglob(dir: string, match: (name: string) => boolean): Generator<string> {
-    let entries: fs.Dirent[];
+    let rootReal: string;
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        rootReal = fs.realpathSync(dir);
     } catch {
         return;
     }
-    // Sort for determinism (Path.rglob order is filesystem-dependent in
-    // Python; we only count, so order does not affect the result).
-    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-    for (const e of entries) {
-        const full = path.join(dir, e.name);
-        if (e.isDirectory()) {
-            yield* _rglob(full, match);
-        } else if (match(e.name)) {
-            yield full;
+    const confined = (p: string): string | null => {
+        try {
+            const real = fs.realpathSync(p);
+            const rel = path.relative(rootReal, real);
+            const inside = real === rootReal || (rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel));
+            return inside ? real : null;
+        } catch {
+            return null; // broken symlink → explicitly not yielded
+        }
+    };
+    const visited = new Set<string>([rootReal]);
+    function* walk(current: string): Generator<string> {
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        // Sort for determinism (Path.rglob order is filesystem-dependent in
+        // Python; we only count, so order does not affect the result).
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const e of entries) {
+            const full = path.join(current, e.name);
+            if (e.isDirectory()) {
+                yield* walk(full);
+            } else if (e.isSymbolicLink()) {
+                const real = confined(full);
+                if (real === null) {
+                    continue;
+                }
+                let st: fs.Stats;
+                try {
+                    st = fs.statSync(full);
+                } catch {
+                    continue;
+                }
+                if (st.isDirectory()) {
+                    if (visited.has(real)) {
+                        continue;
+                    }
+                    visited.add(real);
+                    yield* walk(full);
+                } else if (st.isFile() && match(e.name)) {
+                    yield full;
+                }
+            } else if (e.isFile() && match(e.name)) {
+                yield full;
+            }
         }
     }
+    yield* walk(dir);
 }
 
 /** Yield immediate child files of dir matching `match`. */

package/src/server/schemas/settings.ts

@@ -205,6 +205,24 @@ export const settingsSchema = z.object({
             'Optional planning horizon (weeks) the agent shows in roadmap framing ("next 4 weeks"). Set 0 to omit the horizon — most teams prefer to ship without a hardcoded window.',
         ),
     }),
+    planning: z.object({
+        challenge_on_create: z.boolean().default(true).describe(
+            'Gate C — plan-confidence gate before authoring. true (default) = a plan-artifact ask (/roadmap:create, roadmap-writing, /feature:plan, /feature:roadmap) first checks the four 95%-confidence conditions from /challenge-me vision; any gap routes into the interview (or the inline degrade protocol) before authoring, and a confident pass emits exactly one marker line. false = inert, plan asks author directly. An explicit user bypass always wins for that turn and is counted.',
+        ),
+        risk_review: z.boolean().default(true).describe(
+            'Gate R1 — plan-risk review. true (default) = every ready (non-draft) plan must carry a schema-valid "## Risk Register" section (ranked risks, mitigation + anchor per row, freshness marker, exact honest-null grammar), enforced by lint_plan_risk_register at pre-push + CI. false = escape hatch, the validator skips.',
+        ),
+        completion_review: z.boolean().default(true).describe(
+            'Gate R2 — completion review at 100% roadmap completion / pre-PR. true (default) = a findings-before-fixes review by a fresh reviewer context must exist for the current diff hash (or an exact honest-null / skip declaration) before fix commits and PR creation, enforced by check_completion_review at pre-push + CI (CI authoritative; a crashed validator warns and allows). false = escape hatch, the validator skips.',
+        ),
+    })
+        // `.default({})` is load-bearing, not cosmetic: without it the SECTION is
+        // required, so any settings payload that omits `planning` fails with
+        // `ZodError: planning Required` — which contradicts this gate family's own
+        // contract ("missing key = true" for all three) and reds every server
+        // test whose fixture predates the section. With the default, an absent
+        // section materialises as the three `true` leaves the contract promises.
+        .default({}),
     quality: z.object({
         local_auto_run: z.boolean().default(false).describe(
             'Run quality tools (linters, type-checks, formatters) and the local test suite autonomously after edits. Off by default — the agent never runs quality tools proactively and does not ask; the user runs them manually (e.g. /quality-fix) and remote CI is the authoritative gate. The agent only runs a quality tool on an explicit ask, a concrete CI failure, or the new-gate carve-out. Turn on to restore autonomous pipeline runs.',
@@ -247,6 +265,29 @@ export const settingsSchema = z.object({
             'Whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak + thin-projector trimming), consumed by the token-budget-discipline rule. on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask once per session before loading.',
         ),
     }).default({ rich_skills: 'on' }),
+    verbosity: z.object({
+        intent_announcements: z.boolean().default(false).describe(
+            'Intent narration before tool batches ("Let me check X…"). Only honored when personal.play_by_play is ALSO true (the direct-answers narration carve-out requires both). false (default) = act and emit the result.',
+        ),
+        preview_artifacts: z.boolean().default(false).describe(
+            'Show generated commit messages, PR titles/bodies, branch names before acting. false (default) = use generated content directly (/commit terse path).',
+        ),
+        routine_confirmations: z.boolean().default(false).describe(
+            'Confirmation prompts for routine workflow steps with one obvious answer. Iron-Law gates (commit-policy, scope-control git-ops, Hard Floor) ALWAYS ask regardless.',
+        ),
+        offer_council_in_delivery: z.boolean().default(false).describe(
+            'Offer "run AI Council on this?" inside delivery commands (/feature-plan, /review-changes, /roadmap-create). Council commands themselves are unaffected.',
+        ),
+        post_action_reports: z.enum(['off', 'minimal', 'full']).default('minimal').describe(
+            'Status blocks after a successful action. off = errors only; minimal (default) = one-line confirmation; full = bullet list.',
+        ),
+    }).default({
+        intent_announcements: false,
+        preview_artifacts: false,
+        routine_confirmations: false,
+        offer_council_in_delivery: false,
+        post_action_reports: 'minimal',
+    }),
     code_style: z.object({
         docblocks: z.enum(['minimal', 'full']).default('minimal').describe(
             'Consumed by the code-comment-discipline rule. minimal (default) = no signature-mirroring docblocks; docblocks only for machine-relevant precision (generics, array shapes) or genuine why-context. full = the exported public surface of a library package may carry one-line summary docblocks; the redundancy ban still holds.',

package/dist/cli-delegate/{chunk-XX6TOPD7.js → chunk-WR6GTRHJ.js}

@@ -1,10 +1,10 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
-import {
-  resolve_project_root
-} from "./chunk-HJ6DAJHR.js";
 import {
   resolvePackageRoot
 } from "./chunk-MCJYCQPF.js";
+import {
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
 
 // src/scripts/_cli/cmd_migrate.ts
 import { spawnSync } from "node:child_process";