@event4u/agent-config 9.8.0 → 9.9.0

package/src/scripts/code_graph/sqlite_store.ts

@@ -0,0 +1,174 @@
+/**
+ * Derived SQLite twin of the code-graph JSON cache (ADR-129, Phase 6 of
+ * road-to-reachable-code-memory).
+ *
+ * `build` additionally emits `<cache>.sqlite3` beside the canonical JSON;
+ * the query path PREFERS the SQLite twin (cheap freshness check via the
+ * JSON's stat + stored source_checksum) and falls back to parsing the JSON
+ * when the twin is absent, stale, corrupt, version-mismatched, or the
+ * runtime has no `node:sqlite` (engines floor is Node >=20.11; the module
+ * needs >=22.5 — sqlite_guard's lazy import keeps old Nodes on the JSON
+ * path).
+ *
+ * INVARIANTS (ADR-129):
+ * - JSON stays canonical and byte-deterministic; the SQLite file is a
+ *   derived, gitignored, disposable accelerator. Rollback = delete it.
+ * - Answers are byte-identical on both stores — the loader reconstructs the
+ *   exact `CodeGraph` object (`serializeGraph` equality is the test).
+ * - Rollback triggers (recorded, not ship gates): query p95 <= 50 ms and
+ *   heap <= 10 MB on the SQLite path — a miss reverts THAT store to the
+ *   JSON fallback plus an incident note.
+ * - Zero-touch upgrades (Phase 7): `PRAGMA user_version` stamps the schema;
+ *   a mismatch / corrupt / absent twin is silently rebuilt from the
+ *   committed truth (the JSON) on the next load — never a user action.
+ */
+import * as fs from 'node:fs';
+
+import {
+    isSqliteAvailableSync,
+    loadSqliteSync,
+    readUserVersion,
+    stampUserVersion,
+} from '../_lib/sqlite_guard.js';
+import type { CodeEdge, CodeGraph, CodeNode } from './types.js';
+
+/** Bump on ANY table/column change — a mismatch sends readers to the JSON. */
+export const GRAPH_STORE_VERSION = 1;
+
+/** Derived twin path for a JSON cache path.
+ * cache-invalidation: versioned via PRAGMA user_version (GRAPH_STORE_VERSION), not the filename. */
+export function sqliteTwinPath(jsonPath: string): string {
+    return jsonPath.endsWith('.json') ? `${jsonPath.slice(0, -5)}.sqlite3` : `${jsonPath}.sqlite3`;
+}
+
+/**
+ * Emit the SQLite twin beside the JSON cache. Best-effort: returns false
+ * (never throws) when `node:sqlite` is unavailable or the write fails — the
+ * JSON path remains the source of truth either way.
+ *
+ * Storage model: nodes/edges land in real tables (queryable, and the FTS-free
+ * structure the rollback triggers measure), while `meta.graph_json` carries
+ * the byte-exact canonical serialization so the loader can guarantee
+ * byte-identical answers without re-deriving key order.
+ */
+export function emitSqliteTwin(graph: CodeGraph, serialized: string, jsonPath: string): boolean {
+    if (!isSqliteAvailableSync()) return false;
+    const twin = sqliteTwinPath(jsonPath);
+    const tmp = `${twin}.tmp-${process.pid}`;
+    try {
+        const { DatabaseSync } = loadSqliteSync('code_graph.sqlite_store');
+        let stat: fs.Stats;
+        try {
+            stat = fs.statSync(jsonPath);
+        } catch {
+            return false; // no canonical JSON — nothing to twin
+        }
+        fs.rmSync(tmp, { force: true });
+        const db = new DatabaseSync(tmp);
+        try {
+            db.exec('PRAGMA journal_mode = MEMORY');
+            db.exec(
+                'CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);' +
+                    'CREATE TABLE nodes (id TEXT PRIMARY KEY, label TEXT NOT NULL, kind TEXT, source_file TEXT, l0 INTEGER, l1 INTEGER, l2 INTEGER, l3 INTEGER);' +
+                    'CREATE TABLE edges (source TEXT NOT NULL, target TEXT NOT NULL, relation TEXT NOT NULL, confidence TEXT NOT NULL, candidates TEXT);' +
+                    'CREATE INDEX edges_source ON edges(source);' +
+                    'CREATE INDEX edges_target ON edges(target);',
+            );
+            const meta = db.prepare('INSERT INTO meta (key, value) VALUES (?, ?)');
+            meta.run('source_checksum', graph.source_checksum);
+            meta.run('json_size', String(stat.size));
+            meta.run('json_mtime_ms', String(stat.mtimeMs));
+            meta.run('graph_json', serialized);
+            const insNode = db.prepare(
+                'INSERT INTO nodes (id, label, kind, source_file, l0, l1, l2, l3) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+            );
+            for (const n of graph.nodes) {
+                const loc = n.source_location ?? [];
+                insNode.run(
+                    n.id,
+                    n.label,
+                    (n as { kind?: string }).kind ?? null,
+                    n.source_file ?? null,
+                    (loc[0] as number | undefined) ?? null,
+                    (loc[1] as number | undefined) ?? null,
+                    (loc[2] as number | undefined) ?? null,
+                    (loc[3] as number | undefined) ?? null,
+                );
+            }
+            const insEdge = db.prepare(
+                'INSERT INTO edges (source, target, relation, confidence, candidates) VALUES (?, ?, ?, ?, ?)',
+            );
+            for (const e of graph.edges) {
+                insEdge.run(e.source, e.target, e.relation, e.confidence, e.candidates ? JSON.stringify(e.candidates) : null);
+            }
+            stampUserVersion(db, GRAPH_STORE_VERSION);
+        } finally {
+            db.close();
+        }
+        fs.renameSync(tmp, twin);
+        return true;
+    } catch {
+        fs.rmSync(tmp, { force: true });
+        return false;
+    }
+}
+
+/**
+ * Load the canonical serialization from a FRESH SQLite twin, or null when the
+ * twin is absent / stale (JSON changed since emission) / corrupt /
+ * version-mismatched / unsupported runtime. Callers fall back to reading the
+ * JSON — and best-effort re-emit the twin from it (zero-touch rebuild).
+ */
+export function loadSerializedFromTwin(jsonPath: string): string | null {
+    if (!isSqliteAvailableSync()) return null;
+    const twin = sqliteTwinPath(jsonPath);
+    if (!fs.existsSync(twin)) return null;
+    let stat: fs.Stats;
+    try {
+        stat = fs.statSync(jsonPath);
+    } catch {
+        return null; // canonical JSON gone — the twin has no truth to mirror
+    }
+    try {
+        const { DatabaseSync } = loadSqliteSync('code_graph.sqlite_store');
+        const db = new DatabaseSync(twin, { readOnly: true });
+        try {
+            if (readUserVersion(db) !== GRAPH_STORE_VERSION) return null;
+            const rows = db.prepare('SELECT key, value FROM meta').all() as { key: string; value: string }[];
+            const meta = new Map(rows.map((r) => [r.key, r.value]));
+            if (meta.get('json_size') !== String(stat.size)) return null;
+            if (meta.get('json_mtime_ms') !== String(stat.mtimeMs)) return null;
+            const serialized = meta.get('graph_json');
+            return serialized && serialized.length > 0 ? serialized : null;
+        } finally {
+            db.close();
+        }
+    } catch {
+        // Corrupt twin is a non-event: drop it so the next build re-emits.
+        fs.rmSync(twin, { force: true });
+        return null;
+    }
+}
+
+/** Structured node/edge access for future in-process consumers (kept minimal:
+ * the loader above guarantees byte-identical answers; these are for tooling). */
+export function twinCounts(jsonPath: string): { nodes: number; edges: number } | null {
+    if (!isSqliteAvailableSync()) return null;
+    const twin = sqliteTwinPath(jsonPath);
+    if (!fs.existsSync(twin)) return null;
+    try {
+        const { DatabaseSync } = loadSqliteSync('code_graph.sqlite_store');
+        const db = new DatabaseSync(twin, { readOnly: true });
+        try {
+            const n = db.prepare('SELECT COUNT(*) AS c FROM nodes').get() as { c: number };
+            const e = db.prepare('SELECT COUNT(*) AS c FROM edges').get() as { c: number };
+            return { nodes: n.c, edges: e.c };
+        } finally {
+            db.close();
+        }
+    } catch {
+        return null;
+    }
+}
+
+export type { CodeEdge, CodeGraph, CodeNode };

package/src/scripts/condense.ts

@@ -965,17 +965,25 @@ function _read_rule_packs(): string[] | null {
 }
 
 /**
- * Whether a rule source file projects under the given workspace + pack
- * scopes. Both scopes are independent constraints: when configured, the
- * rule's frontmatter list must intersect (installed workspaces AND
- * installed packs). Kernel always projects; untagged axes fail safe.
+ * Whether a rule source file projects under the given workspace + pack +
+ * role scopes. Each configured scope is an independent constraint: the
+ * rule's frontmatter list must intersect it. Kernel always projects;
+ * untagged axes fail safe.
+ *
+ * `role_scope` is the subagent-role axis (road-to-lean-agent-init Phase 4):
+ * a `roles:` frontmatter list, parallel to `workspaces:`/`packs:`, so a
+ * review-worker subagent's rule projection can be scoped to review-shaped
+ * rules instead of the full set. Additive — the new param defaults to
+ * `null` (no role filtering), so every existing 2- and 3-arg call site
+ * compiles and behaves unchanged.
  */
 export function rule_in_scope(
     source_path: string,
     scope: readonly string[] | null,
     pack_scope: readonly string[] | null = null,
+    role_scope: readonly string[] | null = null,
 ): boolean {
-    if (scope === null && pack_scope === null) {
+    if (scope === null && pack_scope === null && role_scope === null) {
         return true;
     }
     const [meta] = _parse_frontmatter(_readText(source_path));
@@ -994,7 +1002,7 @@ export function rule_in_scope(
         }
         return values.some((v) => configured.includes(v));
     };
-    return axis('workspaces', scope) && axis('packs', pack_scope);
+    return axis('workspaces', scope) && axis('packs', pack_scope) && axis('roles', role_scope);
 }
 
 /** List rule basenames under RULES_SOURCE, workspace/pack scope applied. */

package/src/scripts/context_hygiene_hook.ts

@@ -36,6 +36,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 // `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
 // § Concurrency, Phase 7.4).
 import { atomic_write_json } from "./hooks/state_io.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 // NOTE: the Python docstring says `agents/runtime/state/`, but the code
 // constant is `agents/state/`. Replicated verbatim — this is a latent
@@ -252,11 +253,7 @@ function parse_args(argv: string[]): ParsedArgs {
 }
 
 function _readStdin(): string {
-  try {
-    return fs.readFileSync(0, "utf-8");
-  } catch {
-    return "";
-  }
+  return readHookStdin();
 }
 
 export function main(argv?: string[]): number {
@@ -264,7 +261,13 @@ export function main(argv?: string[]): number {
   return run(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/council_cli.ts

@@ -117,6 +117,15 @@ import {
 } from './ai_council/consensus.js';
 import * as _shadow from './ai_council/shadow_dispatch.js';
 import * as _lowimpact from './ai_council/low_impact.js';
+import {
+    apply_chairman_override,
+    assign_stances,
+    build_blind_labels,
+    OUTSIDER_STANCE_NAME,
+    parse_chairman_override,
+    render_deanonymization_block,
+    with_chairman_fields,
+} from './ai_council/blind_review.js';
 
 // ── argparse-style exit plumbing ────────────────────────────────────
 // Mirror CPython argparse: a `prog: error: …` line on stderr + exit 2.
@@ -1168,16 +1177,36 @@ function _maybe_run_chairman(
             response: null,
         };
     }
-    // Transcript WITH identities (the chairman judges attributed positions) +
-    // the lens synthesis template as the authoring instruction.
-    const transcript = responses
-        .filter((r) => r.error === null && r.text.trim() !== '')
-        .map((r) => `## ${r.provider} - ${r.model}\n\n${r.text.trim()}`)
-        .join('\n\n---\n\n');
-    const synth_prompt =
-        `You are the council CHAIRMAN. You did not deliberate. Author the synthesis ` +
-        `of the attributed member positions below, following the template.\n\n` +
-        `${synthesis_template(question.mode)}\n\n---\n\n${transcript}`;
+    // road-to-council-blind-review Phase 1 (Ü1): --blind-chairman shuffles the
+    // transcript deterministically (seeded by the question text) and strips
+    // identity to Response-A/B/… labels, reusing the EXISTING
+    // `consensus.anonymize_responses` seam. The default path below (transcript
+    // WITH identities — "the chairman judges attributed positions") is
+    // byte-identical to today.
+    const blind = args.blind_chairman === true;
+    let transcript: string;
+    let blind_label_to_source: Map<string, string> | null = null;
+    const successful = responses.filter((r) => r.error === null && r.text.trim() !== '');
+    if (blind) {
+        const pairs: Array<[string, string]> = successful.map((r) => [`${r.provider}:${r.model}`, r.text]);
+        const built = build_blind_labels(question.user_prompt, pairs);
+        transcript = built.transcript;
+        blind_label_to_source = built.label_to_source;
+    } else {
+        transcript = successful
+            .map((r) => `## ${r.provider} - ${r.model}\n\n${r.text.trim()}`)
+            .join('\n\n---\n\n');
+    }
+    // Ü3: --chairman-fields appends the two mandatory trailing sections.
+    const template =
+        args.chairman_fields === true ? with_chairman_fields(synthesis_template(question.mode)) : synthesis_template(question.mode);
+    const synth_prompt = blind
+        ? `You are the council CHAIRMAN. You did not deliberate. Author the synthesis ` +
+          `of the anonymized member positions below (labels A–E). Do not guess ` +
+          `identities.\n\n${template}\n\n---\n\n${transcript}`
+        : `You are the council CHAIRMAN. You did not deliberate. Author the synthesis ` +
+          `of the attributed member positions below, following the template.\n\n` +
+          `${template}\n\n---\n\n${transcript}`;
     const synthQ = new CouncilQuestion({
         mode: question.mode,
         user_prompt: synth_prompt,
@@ -1197,7 +1226,13 @@ function _maybe_run_chairman(
             response: r,
         };
     }
-    return { member: sel.member, annotation: sel.annotation, text: r.text, response: r };
+    // Blind is only at decision time — de-anonymization lands in the audit
+    // artifact immediately after the verdict, never fed back into a prompt.
+    const final_text =
+        blind && blind_label_to_source !== null
+            ? `${r.text.trim()}\n\n${render_deanonymization_block('### De-anonymization (post-verdict)', blind_label_to_source)}`
+            : r.text;
+    return { member: sel.member, annotation: sel.annotation, text: final_text, response: r };
 }
 
 function _maybe_run_peer_review(
@@ -1840,6 +1875,15 @@ function _apply_solo_dispatch(members: ExternalAIClient[]): [ExternalAIClient[],
     ];
 }
 
+/** `--chairman` value → parsed override, or `ArgumentTypeError` on malformed input. */
+function _resolved_chairman_override(raw: string | null) {
+    try {
+        return parse_chairman_override(raw);
+    } catch (exc) {
+        throw new ArgumentTypeError(exc instanceof Error ? exc.message : String(exc));
+    }
+}
+
 function cmd_run(
     args: Args,
     opts: { settings?: Dict | null; members?: ExternalAIClient[] | null; table?: PriceTable | null } = {},
@@ -1850,7 +1894,12 @@ function cmd_run(
     if (settings === null) {
         settings = load_settings();
     }
-    const ai_cfg = _isDict(settings) ? ((settings['ai_council'] as Dict) || {}) : {};
+    // road-to-council-blind-review Phase 1: `--chairman host|auto|member:NAME`
+    // is a pure runtime override, never a config write.
+    const ai_cfg = apply_chairman_override(
+        _isDict(settings) ? ((settings['ai_council'] as Dict) || {}) : {},
+        _resolved_chairman_override(_getattr<string | null>(args, 'chairman', null)),
+    ) as Dict;
     const advisor_plans = _build_advisor_plans(ai_cfg, REPO_ROOT);
     const explicit_overrides = _parse_model_overrides(_getattr<string[] | null>(args, 'model', null));
     const skipped: Dict[] = [];
@@ -1978,6 +2027,21 @@ function cmd_run(
         _isDict(ai_cfg) &&
         _isDict(ai_cfg['stance_tally']) &&
         (ai_cfg['stance_tally'] as Dict)['enabled'] === true;
+    // road-to-council-blind-review Phase 1 (Ü2): five orthogonal stances
+    // rotated deterministically over the config-ordered member list; the
+    // outsider seat additionally drops project_context. Default off.
+    const stances_on = args.stances === true;
+    const stance_assignment = stances_on ? assign_stances(members.map((m) => m.name), question.user_prompt) : null;
+    const member_prompt_suffix = stance_assignment
+        ? new Map(Array.from(stance_assignment.entries()).map(([name, s]) => [name, s.prompt]))
+        : null;
+    const no_project_context_members = stance_assignment
+        ? new Set(
+              Array.from(stance_assignment.entries())
+                  .filter(([, s]) => s.name === OUTSIDER_STANCE_NAME)
+                  .map(([name]) => name),
+          )
+        : null;
     const stance_repairs: CouncilResponse[] = [];
     const responses = consult(members, question, budget, {
         table,
@@ -1986,6 +2050,8 @@ function cmd_run(
         rounds,
         advisor_plans,
         stance_tally: stance_tally_on,
+        member_prompt_suffix,
+        no_project_context_members,
         // Interactive one-line confirm (cmd_run has no --auto-continue); the
         // repaired-call cost is collected so cost_usd_actual stays honest.
         on_stance_repair: stance_tally_on
@@ -2009,6 +2075,22 @@ function cmd_run(
     );
     const consensus = _maybe_run_consensus(ai_cfg, question, members, responses, budget, table, project, args);
     const chairman = _maybe_run_chairman(ai_cfg, question, members, responses, budget, table, project, args);
+    // road-to-council-blind-review Phase 1 (Ü1), host-path only: when no
+    // member chairman ran (mode === 'host'), the blind mapping is computed
+    // here (seeded from the question text) and persisted for a later
+    // `council:render` to blind the response headers. The member-chairman
+    // path (below, inside `_maybe_run_chairman`) blinds inline instead.
+    const blind_chairman_on = args.blind_chairman === true;
+    const chairman_fields_on = args.chairman_fields === true;
+    let blind_review_map: Map<string, string> | null = null;
+    if (blind_chairman_on && chairman === null) {
+        const pairs: Array<[string, string]> = responses
+            .filter((r) => r.error === null && r.text.trim() !== '')
+            .map((r) => [`${r.provider}:${r.model}`, r.text]);
+        if (pairs.length > 0) {
+            blind_review_map = build_blind_labels(question.user_prompt, pairs).label_to_source;
+        }
+    }
     const estimated_total = estimates.reduce((acc, e) => acc + _total_usd(e), 0.0);
     let actual_total = 0.0;
     const all_responses: CouncilResponse[] = [...responses];
@@ -2043,6 +2125,9 @@ function cmd_run(
         cost_usd_estimated: _pyRound(estimated_total, 6),
         cost_usd_actual: _pyRound(actual_total, 6),
         stance_tally: stance_tally_on,
+        stances: stances_on,
+        blind_chairman: blind_chairman_on,
+        chairman_fields: chairman_fields_on,
         responses: _serialise_responses(responses),
     };
     if (peer_review !== null) {
@@ -2054,6 +2139,9 @@ function cmd_run(
     if (chairman !== null) {
         payload['chairman'] = { member: chairman.member, annotation: chairman.annotation, text: chairman.text };
     }
+    if (blind_review_map !== null) {
+        payload['blind_review_map'] = _mapToObject(blind_review_map);
+    }
     const out_path = _validate_council_output_path(args.output as string, {
         kind: 'responses',
         subcommand: 'run',
@@ -2452,12 +2540,18 @@ function cmd_render(args: Args): number {
     }
     const consensus = _deserialise_consensus(payload['consensus'] as Dict);
     const peer_review = _deserialise_peer_review(payload['peer_review'] as Dict);
+    // road-to-council-blind-review Phase 1: a persisted `blind_review_map`
+    // means `--blind-chairman` ran on the host path (no member chairman) —
+    // blind the response headers + append the de-anonymization map.
+    const blind_map_raw = payload['blind_review_map'];
     const body = render(_deserialise_responses(items), {
         mode: mode ?? null,
         prose_synthesis: prose,
         consensus,
         peer_review,
         stance_tally: payload['stance_tally'] === true,
+        chairman_fields: payload['chairman_fields'] === true,
+        blind: _isDict(blind_map_raw) ? { label_to_source: _objToMap(blind_map_raw as Dict) } : null,
         chairman: _isDict(payload['chairman'])
             ? (payload['chairman'] as { member: string | null; annotation: string; text: string | null })
             : null,
@@ -2672,6 +2766,11 @@ interface Args {
     auto_continue: boolean;
     restate?: boolean;
     continue_as_debate: string | null;
+    // road-to-council-blind-review Phase 1 — flag-gated, default-off (`run` only)
+    chairman: string | null;
+    blind_chairman: boolean;
+    stances: boolean;
+    chairman_fields: boolean;
     // render / replay
     responses?: string | null;
     include_member_arguments: boolean | null;
@@ -2726,6 +2825,15 @@ function _defaultArgs(): Args {
         prose_synthesis: null,
         auto_continue: false,
         continue_as_debate: null,
+        chairman: null,
+        // Ü1 ADOPTED (road-to-council-blind-review Phase 3, 2026-07-28):
+        // blind synthesis is the default — 0/10 + 0/10 pre-registered
+        // degradation triggers on the n=10 A/B; opt out per-invocation
+        // with --no-blind-chairman (the audit artifact always keeps the
+        // post-verdict de-anonymization map either way).
+        blind_chairman: true,
+        stances: false,
+        chairman_fields: false,
         responses: null,
         include_member_arguments: null,
         low_impact_stats: false,
@@ -2788,6 +2896,12 @@ function _specsFor(cmd: string): { positionals: string[]; opts: OptSpec[]; requi
                     { flag: '--single', takesValue: false, apply: (o) => (o.single = true) },
                     { flag: '--prose-synthesis', takesValue: false, apply: (o) => (o.prose_synthesis = true) },
                     { flag: '--no-prose-synthesis', takesValue: false, apply: (o) => (o.prose_synthesis = false) },
+                    // road-to-council-blind-review Phase 1 — flag-gated, default-off.
+                    { flag: '--chairman', takesValue: true, apply: (o, v) => (o.chairman = v) },
+                    { flag: '--blind-chairman', takesValue: false, apply: (o) => (o.blind_chairman = true) },
+                    { flag: '--no-blind-chairman', takesValue: false, apply: (o) => (o.blind_chairman = false) },
+                    { flag: '--stances', takesValue: false, apply: (o) => (o.stances = true) },
+                    { flag: '--chairman-fields', takesValue: false, apply: (o) => (o.chairman_fields = true) },
                 ],
                 requiredOpts: ['--output'],
             };