@event4u/agent-config 16.3.0 → 16.4.0

package/src/scripts/install.ts

@@ -334,15 +334,10 @@ const LEGACY_RENAME_MAP: Record<string, string> = {
     open_edited_files: 'personal.open_edited_files',
     user_name: 'personal.user_name',
     rtk_installed: 'personal.rtk_installed',
-    minimal_output: 'personal.minimal_output',
-    play_by_play: 'personal.play_by_play',
-    pr_comment_bot_icon: 'project.pr_comment_bot_icon',
-    pr_template: 'project.pr_template',
     upstream_repo: 'project.upstream_repo',
     improvement_pr_branch_prefix: 'project.improvement_pr_branch_prefix',
     github_pr_reply_method: 'github.pr_reply_method',
     eloquent_access_style: 'eloquent.access_style',
-    skill_improvement_pipeline: 'pipelines.skill_improvement',
     subagent_implementer_model: 'subagents.implementer_model',
     subagent_judge_model: 'subagents.judge_model',
     subagent_max_parallel: 'subagents.max_parallel',
@@ -3032,7 +3027,7 @@ function _deploy_global_content(
                     warn(`claude-code: thinned rule layer not written — ${String(e)}`);
                 }
             }
-            if (!state.QUIET) for (const l of installReceiptBudgetLines(package_root)) info(l);
+            if (!state.QUIET) for (const l of installReceiptBudgetLines(package_root, undefined, { thisDeploy: new Map([[anchor, current_files]]) })) info(l);
         }
 
         const missing_targets = _verify_deploy_targets(anchor, plan);
@@ -4773,27 +4768,11 @@ function _read_consumer_auto_switch(project_root: string): string {
 /**
  * Team-mode setup hint (road-to-team-mode Phase 1 Step 2) — a one-line
  * recommendation printed after a claude-code install/init pointing at the
- * doctor `team` section. Returns null when suppressed via
- * `ai_team.suppress_setup_hint: true` in `.agent-settings.yml` (default
- * false; the `ai_team` block may not exist in the schema yet — read
- * leniently). Pointer only: never auto-installs, never modifies
- * `~/.claude/plugins`.
+ * doctor `team` section. Always shown: the `ai_team.suppress_setup_hint` key
+ * that could silence it was retired with its default (false). Pointer only:
+ * never auto-installs, never modifies `~/.claude/plugins`.
  */
-function _team_setup_hint_line(project_root: string): string | null {
-    let data: Record<string, unknown>;
-    try {
-        data = load_agent_settings({ project_path: _resolve_settings_read(project_root) });
-    } catch {
-        data = {};
-    }
-    const ai_team = _isPlainObject(data) ? data['ai_team'] : null;
-    const flag = _isPlainObject(ai_team)
-        ? (ai_team as Record<string, unknown>)['suppress_setup_hint']
-        : null;
-    const suppressed =
-        flag === true ||
-        (typeof flag === 'string' && ['true', 'yes', 'on', '1'].includes(flag.trim().toLowerCase()));
-    if (suppressed) return null;
+function _team_setup_hint_line(): string {
     return (
         '  • Claude Code team mode (optional cross-model review via the official ' +
         'codex plugin): run `agent-config doctor --check team` for setup status.'
@@ -5006,11 +4985,8 @@ function _main_project_install(
         }
         mcp_consent.printResiduals(tools, state.QUIET);
         if (_is_tool_enabled(tools, 'claude-code')) {
-            const team_hint = _team_setup_hint_line(project_root);
-            if (team_hint !== null) {
-                process.stdout.write(team_hint + '\n');
-                process.stdout.write('\n');
-            }
+            process.stdout.write(_team_setup_hint_line() + '\n');
+            process.stdout.write('\n');
         }
     }
 

package/src/scripts/lint_blocker_citations.ts

@@ -0,0 +1,198 @@
+#!/usr/bin/env tsx
+/**
+ * Every `path:line` a roadmap blocker cites must still point at a line.
+ *
+ * A blocker's `What to do` and `Resolved when` lean on citations like
+ * `src/scripts/foo.ts:120-134`. Line numbers move with every edit above them,
+ * and nothing re-reads a citation once it is written — `check_references`
+ * resolves names, not line numbers. A cited range that now runs past the end
+ * of its file sends the reader of the blocker to nothing.
+ *
+ * Scope: the `## Blockers` section of every active roadmap and every stub.
+ * Checked: the file exists and the last cited line is within its length.
+ * Not checked: what the line says — a content check would red on every
+ * harmless edit above it.
+ *
+ * A citation is a repository-relative path with a file extension, `:`, a line
+ * number and an optional `-<line>` end. A bare `:354-359` with no path is
+ * relative to prose above it and is not read.
+ *
+ * Existing misses are ratcheted (`gate-violation-baselines.json`, gate
+ * `lint_blocker_citations`): line numbers drift, so a miss already in the tree
+ * is drift rather than a new defect, and the count may only fall.
+ *
+ * Exit codes: 0 within the ratchet · 1 above it · 2 usage error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { checkRatchet } from './_lib/gate_baseline.js';
+import { reportScanned } from './_lib/scan_scope.js';
+
+type MissKind = 'missing-file' | 'beyond-end';
+
+interface Citation {
+    roadmap: string;
+    line: number;
+    target: string;
+    first: number;
+    last: number;
+}
+
+interface Miss extends Citation {
+    kind: MissKind;
+    length: number | null;
+}
+
+const BLOCKERS_SECTION_RE = /^##[ \t]+Blockers[ \t]*$/im;
+const NEXT_H2_RE = /^##[ \t]+\S/m;
+const CITATION_RE = /(?<![\w./:-])((?:[\w.-]+\/)*[\w-][\w.-]*\.[A-Za-z0-9]+):(\d+)(?:-(\d+))?(?!\d)/g;
+
+/** Citations inside the `## Blockers` section, with their line in the roadmap. */
+function citationsIn(text: string, roadmap: string): Citation[] {
+    const m = BLOCKERS_SECTION_RE.exec(text);
+    if (!m) {
+        return [];
+    }
+    const start = m.index + m[0].length;
+    const rest = text.slice(start);
+    const h2 = NEXT_H2_RE.exec(rest);
+    const section = h2 ? rest.slice(0, h2.index) : rest;
+    const lineOffset = text.slice(0, start).split('\n').length - 1;
+    const out: Citation[] = [];
+    section.split('\n').forEach((raw, i) => {
+        for (const c of raw.matchAll(CITATION_RE)) {
+            const first = Number(c[2]);
+            const last = c[3] === undefined ? first : Number(c[3]);
+            out.push({ roadmap, line: lineOffset + i + 1, target: c[1] as string, first, last });
+        }
+    });
+    return out;
+}
+
+/** Line count of the cited file, repo-relative first, then relative to the citing roadmap. */
+function _lengthOf(root: string, c: Citation): number | null {
+    for (const abs of [path.join(root, c.target), path.join(root, path.dirname(c.roadmap), c.target)]) {
+        if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+            return fs.readFileSync(abs, 'utf8').replace(/\n$/, '').split('\n').length;
+        }
+    }
+    return null;
+}
+
+function checkCitation(root: string, c: Citation, lengths: Map<string, number | null>): Miss | null {
+    const key = `${path.dirname(c.roadmap)}\0${c.target}`;
+    let length = lengths.get(key);
+    if (length === undefined) {
+        length = _lengthOf(root, c);
+        lengths.set(key, length);
+    }
+    if (length === null) {
+        return { ...c, kind: 'missing-file', length };
+    }
+    return Math.max(c.first, c.last) > length ? { ...c, kind: 'beyond-end', length } : null;
+}
+
+function roadmapFiles(root: string): string[] {
+    const out: string[] = [];
+    for (const sub of ['', 'stubs']) {
+        const dir = path.join(root, 'agents', 'roadmaps', sub);
+        let names: string[];
+        try {
+            names = fs.readdirSync(dir);
+        } catch {
+            continue;
+        }
+        for (const n of names.sort()) {
+            const abs = path.join(dir, n);
+            if (n.endsWith('.md') && fs.statSync(abs).isFile()) {
+                out.push(path.relative(root, abs).split(path.sep).join('/'));
+            }
+        }
+    }
+    return out;
+}
+
+function scanTree(root: string): { misses: Miss[]; scanned: number; citations: number } {
+    const lengths = new Map<string, number | null>();
+    const files = roadmapFiles(root);
+    const misses: Miss[] = [];
+    let citations = 0;
+    for (const rel of files) {
+        for (const c of citationsIn(fs.readFileSync(path.join(root, rel), 'utf8'), rel)) {
+            citations += 1;
+            const miss = checkCitation(root, c, lengths);
+            if (miss) {
+                misses.push(miss);
+            }
+        }
+    }
+    return { misses, scanned: files.length, citations };
+}
+
+const _DEFAULT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+function main(argv: string[] = process.argv.slice(2)): number {
+    let root = _DEFAULT_ROOT;
+    let baselineRoot = _DEFAULT_ROOT;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--root') {
+            const v = argv[i + 1];
+            if (v === undefined) {
+                process.stderr.write('lint_blocker_citations: --root requires a value\n');
+                return 2;
+            }
+            root = path.resolve(v);
+            baselineRoot = root;
+            i += 1;
+        } else {
+            process.stderr.write(`lint_blocker_citations: unknown argument: ${String(arg)}\n`);
+            return 2;
+        }
+    }
+    const { misses, scanned, citations } = scanTree(root);
+    reportScanned({
+        gate: 'lint_blocker_citations',
+        scanned,
+        units: 'roadmap file(s)',
+        roots: ['agents/roadmaps', 'agents/roadmaps/stubs'],
+        allowEmpty: 'EMPTY_VALID: a checkout with no active roadmap cites nothing',
+    });
+    const verdict = checkRatchet({ gate: 'lint_blocker_citations', actual: misses.length, repoRoot: baselineRoot });
+    const lines = misses.map(
+        (m) =>
+            `  ${m.roadmap}:${String(m.line)} · ${m.target}:${String(m.first)}${m.last !== m.first ? `-${String(m.last)}` : ''} · ` +
+            (m.kind === 'missing-file' ? 'file does not exist' : `file has ${String(m.length)} line(s)`),
+    );
+    if (!verdict.ok) {
+        process.stderr.write(`❌  ${verdict.message}\n`);
+        process.stderr.write(`${lines.join('\n')}\n`);
+        return 1;
+    }
+    process.stdout.write(
+        `✅  lint_blocker_citations: ${String(citations)} citation(s) in ${String(scanned)} roadmap file(s). ${verdict.message}\n`,
+    );
+    if (lines.length > 0) {
+        process.stdout.write(`${lines.join('\n')}\n`);
+    }
+    return 0;
+}
+
+if (process.argv[1] !== undefined) {
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv1 = fs.realpathSync(path.resolve(process.argv[1]));
+        if (here === argv1) {
+            process.exit(main());
+        }
+    } catch {
+        if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+            process.exit(main());
+        }
+    }
+}
+
+export { citationsIn, checkCitation, scanTree, main };
+export type { Citation, Miss };

package/src/scripts/lint_evidence_artifacts.ts

@@ -50,6 +50,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { GateLedger } from './_lib/gate_ledger.js';
 import { resolveBaseRef } from './_lib/ratchet_base_ref.js';
+import { parseExecutionMode } from './_lib/repeated_run.js';
 import { reportScanned } from './_lib/scan_scope.js';
 import { parseHonestNull, parseMarkerLine, parseSkipDeclaration } from './check_completion_review.js';
 
@@ -257,6 +258,14 @@ export function checkFiles(root: string, files: readonly string[], ledger?: Gate
             });
             continue;
         }
+        // The contract's second axis (repeated-run / flaky), orthogonal to the
+        // type marker above — any artifact may declare it.
+        const mode = parseExecutionMode(contents);
+        if (mode.kind === 'invalid') {
+            ledger?.fail(rel, `invalid evidence-mode: ${mode.reason}`);
+            findings.push({ file: rel, reason: `evidence-mode: ${mode.reason}` });
+            continue;
+        }
         ledger?.complete(rel);
     }
     return findings;

package/src/scripts/lint_hook_concern_budget.ts

@@ -52,8 +52,6 @@ function _load_manifest(p: string): Manifest {
 }
 
 interface SettingsBlock {
-    max_per_event?: number;
-    hard_fail?: boolean;
     tier1_concerns?: string[];
 }
 
@@ -66,9 +64,11 @@ function _isFile(p: string): boolean {
 }
 
 /**
- * Minimal YAML walk for `hooks.concern_budget.*`. Mirrors the Python
- * `_read_settings_block` line walker verbatim — no YAML dependency,
- * tolerant of missing keys / blocks.
+ * Minimal YAML walk for `hooks.concern_budget.tier1_concerns`. Mirrors the
+ * Python `_read_settings_block` line walker — no YAML dependency, tolerant of
+ * missing keys / blocks. `max_per_event` and `hard_fail` are not read: those
+ * keys were retired, the cap is {@link DEFAULT_MAX_PER_EVENT} and hard-fail is
+ * the `--strict` argv alone.
  */
 function _read_settings_block(settings_path: string): SettingsBlock {
     const out: SettingsBlock = {};
@@ -107,18 +107,7 @@ function _read_settings_block(settings_path: string): SettingsBlock {
             in_tier1 = false;
         }
         if (in_budget) {
-            let m = /^\s{4}max_per_event\s*:\s*(\d+)/.exec(line);
-            if (m) {
-                out.max_per_event = Number.parseInt(m[1] as string, 10);
-                in_tier1 = false;
-                continue;
-            }
-            m = /^\s{4}hard_fail\s*:\s*(true|false)/.exec(line);
-            if (m) {
-                out.hard_fail = m[1] === 'true';
-                in_tier1 = false;
-                continue;
-            }
+            let m: RegExpExecArray | null;
             if (/^\s{4}tier1_concerns\s*:\s*\[\s*\]/.test(line)) {
                 out.tier1_concerns = [];
                 in_tier1 = false;
@@ -173,8 +162,8 @@ function _check_concern_counts(
             if (count > max_per_event) {
                 warnings.push(
                     `platforms.${plat}.${event}: ${count} concerns ` +
-                        `(threshold ${max_per_event}). Trim or raise ` +
-                        'hooks.concern_budget.max_per_event in .agent-settings.yml.',
+                        `(threshold ${max_per_event}). Trim the cell; the cap is ` +
+                        'a fixed constant in lint_hook_concern_budget.ts.',
                 );
             }
         }
@@ -230,9 +219,9 @@ export function lint(
     }
 
     const settings = _read_settings_block(settings_path);
-    const max_per_event = settings.max_per_event ?? DEFAULT_MAX_PER_EVENT;
+    const max_per_event = DEFAULT_MAX_PER_EVENT;
     const tier1 = settings.tier1_concerns ?? DEFAULT_TIER1;
-    const hard_fail = (settings.hard_fail ?? DEFAULT_HARD_FAIL) || strict;
+    const hard_fail = DEFAULT_HARD_FAIL || strict;
 
     const warnings: string[] = [];
     const errors: string[] = [];