@event4u/agent-config 9.15.0 → 9.17.0

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

@@ -247,6 +247,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/src/shared/userMd/utils.ts

@@ -23,7 +23,7 @@
  * Drop once no consumer ships the legacy file.
  */
 
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 
 /** Frontmatter fence used by the legacy `.agent-user.md` format. */
 const FRONTMATTER_FENCE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;