@event4u/agent-config 9.8.0 → 9.9.0

package/src/scripts/_lib/subagent_spawn.ts

@@ -11,6 +11,8 @@
  * into a subagent — keep the private-data leg narrow.
  */
 
+import * as crypto from 'node:crypto';
+
 export type RoleMode = 'developer' | 'reviewer' | 'tester' | 'po' | 'incident' | 'planner';
 
 const ROLE_MODES: ReadonlySet<string> = new Set<RoleMode>([
@@ -37,6 +39,12 @@ export interface SpawnSelection {
     personas?: string[];
     /** Knowledge slice REFERENCES (ids / paths) — never inline bodies. */
     knowledge_refs?: string[];
+    /**
+     * Hard per-worker token stop-loss (L0b), resolved from the worker's tier
+     * via `worker_budget.budgetForTier`. Null/absent = orchestrator did not
+     * set one (legacy dispatch).
+     */
+    max_tokens_per_worker?: number | null;
 }
 
 export interface SpawnBrief {
@@ -45,6 +53,8 @@ export interface SpawnBrief {
     profile: string | null;
     personas: string[];
     knowledge_refs: string[];
+    /** Per-worker token stop-loss; null = unset (legacy dispatch). */
+    max_tokens_per_worker: number | null;
     warnings: string[];
 }
 
@@ -86,12 +96,55 @@ export function composeSpawnBrief(sel: SpawnSelection): SpawnBrief {
         knowledge_refs = knowledge_refs.slice(0, MAX_KNOWLEDGE_REFS);
     }
 
+    let max_tokens_per_worker: number | null = null;
+    if (sel.max_tokens_per_worker != null) {
+        if (Number.isInteger(sel.max_tokens_per_worker) && sel.max_tokens_per_worker > 0) {
+            max_tokens_per_worker = sel.max_tokens_per_worker;
+        } else {
+            warnings.push(`invalid max_tokens_per_worker '${sel.max_tokens_per_worker}' dropped (positive integer required)`);
+        }
+    }
+
     return {
         task: sel.task,
         role_mode,
         profile: sel.profile ?? null,
         personas,
         knowledge_refs,
+        max_tokens_per_worker,
         warnings,
     };
 }
+
+// ── Prefix-stable payload serialization (road-to-lean-agent-init Phase 4) ──
+
+/**
+ * Serialize a brief into the spawn payload with DETERMINISTIC ordering:
+ * static prefix first (role contract, profile, personas, budget — stable
+ * across dispatches of the same configuration), variable task part last.
+ * No timestamps, no random IDs — the prefix is byte-identical for identical
+ * configurations, which is what provider prompt-caching keys on. The
+ * `cache_hit` audit field records whether the provider actually reused it;
+ * measurement only — no savings claim without provider-response evidence.
+ */
+export function serializeSpawnPayload(brief: SpawnBrief): string {
+    const staticPrefix = JSON.stringify({
+        role_mode: brief.role_mode,
+        profile: brief.profile,
+        personas: brief.personas,
+        max_tokens_per_worker: brief.max_tokens_per_worker,
+    });
+    const variableTail = JSON.stringify({
+        task: brief.task,
+        knowledge_refs: brief.knowledge_refs,
+    });
+    return `${staticPrefix}\n${variableTail}`;
+}
+
+/**
+ * Hex digest of a serialized payload — the `payload_hash` audit field
+ * (never content; 16 hex chars satisfy the audit schema's 8–64 window).
+ */
+export function spawnPayloadHash(payload: string): string {
+    return crypto.createHash('sha256').update(payload, 'utf8').digest('hex').slice(0, 16);
+}

package/src/scripts/_lib/worker_budget.ts

@@ -0,0 +1,107 @@
+/**
+ * Per-worker token stop-loss (L0b — road-to-lean-agent-init Phase 2).
+ *
+ * Pure, no-I/O. A dispatched worker carries a hard `max_tokens_per_worker`
+ * budget keyed by its resolved tier; on hit it returns a STRUCTURED PARTIAL
+ * RESULT + escalation flag to the orchestrator instead of continuing to
+ * explore. Live evidence (2026-07-28): four lookup-class workers burned
+ * 280–327k tokens each — a worker overrunning its budget 20× is a dispatch
+ * error on the wrong rung, not diligence.
+ *
+ * Composes with — replaces nothing:
+ * - the N=3 validation-loop budget (`autonomous-execution`),
+ * - the ADR-109 / `subagent-response-contract` body + 4-status envelope
+ *   (`subagent-steering`): the partial result rides as the body of a
+ *   `BLOCKED` envelope with `budget_hit: true` as the escalation flag.
+ */
+
+import type { Tier } from './subagent_routing.js';
+
+/**
+ * Start values — refined from Phase-3 telemetry (`budget_hit` rate in the
+ * audit stream), never final. `lite` is the roadmap-pinned lookup-class
+ * start value (~15k); `medium`/`high` are conservative seeds an order of
+ * magnitude below the observed 280–327k runaway runs.
+ */
+export const MAX_TOKENS_PER_WORKER: Readonly<Record<Exclude<Tier, 'inherit'>, number>> = {
+    lite: 15_000,
+    medium: 60_000,
+    high: 150_000,
+};
+
+/** Resolve the budget for a worker's tier; `inherit` uses the session tier's budget. */
+export function budgetForTier(tier: Tier, sessionTier: Exclude<Tier, 'inherit'> = 'high'): number {
+    const effective = tier === 'inherit' ? sessionTier : tier;
+    return MAX_TOKENS_PER_WORKER[effective];
+}
+
+/** Where the orchestrator should send the task after a budget hit. */
+export type NextRung = 'primitive' | 'higher-tier-subagent' | 'in-session';
+
+/**
+ * The structured partial result a budget-hit worker returns. Body of a
+ * `BLOCKED` envelope; `budget_hit: true` IS the escalation flag. Refs, not
+ * bodies — same privacy floor as the spawn/response contracts.
+ */
+export interface WorkerPartialResult {
+    budget_hit: true;
+    /** What was found so far — ref tokens (`file:line`, ids, paths), never bodies. */
+    found: string[];
+    /** What remains unexplored, one plain sentence. */
+    remaining: string;
+    /** Suggested next rung for the remainder. */
+    suggested_next_rung: NextRung;
+}
+
+const NEXT_RUNGS: ReadonlySet<string> = new Set<NextRung>(['primitive', 'higher-tier-subagent', 'in-session']);
+
+/** Ref-like guard — mirrors the spawn contract's refs-not-bodies invariant. */
+function isRefLike(s: unknown): s is string {
+    return typeof s === 'string' && s.length > 0 && s.length <= 200 && !s.includes('\n');
+}
+
+export interface BudgetEvaluation {
+    budget_hit: boolean;
+    consumed: number;
+    budget: number;
+    reason: string;
+}
+
+/** Evaluate consumption against the worker's budget. */
+export function evaluateWorkerBudget(consumed: number, budget: number): BudgetEvaluation {
+    const hit = consumed >= budget;
+    return {
+        budget_hit: hit,
+        consumed,
+        budget,
+        reason: hit
+            ? `budget hit (${consumed} >= ${budget}) — return partial result + escalation flag, stop exploring`
+            : `within budget (${consumed} < ${budget})`,
+    };
+}
+
+/**
+ * Validate a partial-result body. Returns the list of violations (empty =
+ * valid). The orchestrator never adopts an invalid partial return — it
+ * re-dispatches or resolves in-session per the synthesis duties.
+ */
+export function validateWorkerPartialResult(input: unknown): string[] {
+    const errors: string[] = [];
+    if (typeof input !== 'object' || input === null) return ['not an object'];
+    const r = input as Record<string, unknown>;
+
+    if (r['budget_hit'] !== true) errors.push('budget_hit must be literally true (the escalation flag)');
+    if (!Array.isArray(r['found'])) {
+        errors.push('found must be an array of ref tokens');
+    } else {
+        const bodyLike = (r['found'] as unknown[]).filter((x) => !isRefLike(x));
+        if (bodyLike.length > 0) errors.push(`found carries ${bodyLike.length} non-ref entr${bodyLike.length === 1 ? 'y' : 'ies'} (refs only, no bodies)`);
+    }
+    if (typeof r['remaining'] !== 'string' || (r['remaining'] as string).length === 0) {
+        errors.push('remaining must be a non-empty sentence');
+    }
+    if (typeof r['suggested_next_rung'] !== 'string' || !NEXT_RUNGS.has(r['suggested_next_rung'] as string)) {
+        errors.push(`suggested_next_rung must be one of ${[...NEXT_RUNGS].join(' | ')}`);
+    }
+    return errors;
+}

package/src/scripts/ai_council/config.ts

@@ -915,10 +915,15 @@ function _build_model_downgrade(d: Dict): ModelDowngradeConfig {
     if (!_isBool(enabled)) {
         throw new CouncilConfigError('`model_downgrade.enabled` must be a bool.');
     }
-    // A3 (2026-07-20): auto_apply default flipped to TRUE — auto-downgrade is
-    // the default and `auto_apply: false` (or `enabled: false`) is the opt-out.
-    // The cache-coupling gate in council_cli._size_fit_gate keeps it honest.
-    const auto_apply = _get(d, 'auto_apply', true);
+    // 2026-07-28 (road-to-feedback-9.8.0-followups Phase 3): auto_apply
+    // default downgraded back to FALSE (suggest, don't silently apply). The
+    // A3 flip to TRUE (2026-07-20) shipped without a paired quality
+    // measurement and was the only default-ON surface without one (R7
+    // watch-item); until a paired eval measures downgraded-member council
+    // quality, the downgrade surfaces as a suggestion the caller applies
+    // explicitly. Revisit: a paired eval (full-tier vs downgraded, blind
+    // judge) showing held quality re-flips this to true.
+    const auto_apply = _get(d, 'auto_apply', false);
     if (!_isBool(auto_apply)) {
         throw new CouncilConfigError('`model_downgrade.auto_apply` must be a bool.');
     }
@@ -1331,8 +1336,9 @@ function _build_lens_overrides(d: Dict): LensOverridesConfig {
                     `\`lenses.${lens_name}.model_downgrade.enabled\` must be a bool.`,
                 );
             }
-            // Lens overrides inherit the A3 auto-by-default posture.
-            const md_auto = _get(md_block, 'auto_apply', true);
+            // Lens overrides inherit the suggest-by-default posture
+            // (2026-07-28 downgrade of the unmeasured A3 auto-default).
+            const md_auto = _get(md_block, 'auto_apply', false);
             if (!_isBool(md_auto)) {
                 throw new CouncilConfigError(
                     `\`lenses.${lens_name}.model_downgrade.auto_apply\` must be a bool.`,

package/src/scripts/ai_council/orchestrator.ts

@@ -67,6 +67,7 @@ import {
 } from './prompts.js';
 import { count_dissenters, dissent_quota_met, is_near_duplicate } from './debate_gates.js';
 import { parse_stance_line, render_vote_tally, tally_stances } from './stance_tally.js';
+import { CHAIRMAN_FIELDS_ADDENDUM, render_deanonymization_block } from './blind_review.js';
 
 // ── Python-format / stdlib parity helpers ────────────────────────────────
 //
@@ -428,6 +429,20 @@ export interface ConsultOptions {
     on_stance_repair?: ((member: string) => boolean) | null;
     /** Receives each stance-repair response so the caller can account its cost. */
     on_stance_repair_result?: ((r: CouncilResponse) => void) | null;
+    /**
+     * Ü2 (road-to-council-blind-review Phase 1): per-member system-prompt
+     * suffix appended AFTER the base/advisor system prompt — e.g. a stance
+     * framing sentence from `blind_review.assign_stances`. This module stays
+     * stance-agnostic on purpose: the caller supplies plain text keyed by
+     * member name. Default `null` → byte-identical to today.
+     */
+    member_prompt_suffix?: Map<string, string> | null;
+    /**
+     * Ü2 outsider-seat ablation: member names in this set get `project: null`
+     * in their system-prompt build (question + artefact only, no project
+     * context). Default `null` → byte-identical to today.
+     */
+    no_project_context_members?: ReadonlySet<string> | null;
 }
 
 /**
@@ -514,6 +529,8 @@ export function consult(
             project,
             original_ask,
             advisor_plans,
+            member_prompt_suffix: opts.member_prompt_suffix ?? null,
+            no_project_context_members: opts.no_project_context_members ?? null,
             split: suffix_for_round
                 ? { stable: question.user_prompt, suffix: suffix_for_round }
                 : null,
@@ -589,6 +606,10 @@ interface RunRoundOptions {
      * full concatenation (estimates + persistence unchanged).
      */
     split?: { stable: string; suffix: string } | null;
+    /** Ü2 — see `ConsultOptions.member_prompt_suffix`. */
+    member_prompt_suffix?: Map<string, string> | null;
+    /** Ü2 — see `ConsultOptions.no_project_context_members`. */
+    no_project_context_members?: ReadonlySet<string> | null;
 }
 
 /** Run a single round; mutate `spent` with cumulative totals. */
@@ -604,6 +625,8 @@ function _run_round(
     const project = opts.project;
     const original_ask = opts.original_ask;
     const plans = opts.advisor_plans ?? new Map<string, AdvisorPlan>();
+    const member_prompt_suffix = opts.member_prompt_suffix ?? null;
+    const no_project_context_members = opts.no_project_context_members ?? null;
     const base_system_prompt = system_prompt_for(question.mode, {
         project,
         original_ask,
@@ -611,10 +634,22 @@ function _run_round(
 
     const _system_prompt_for_member = (m: ExternalAIClient): string => {
         const plan = plans.get(m.name);
+        // Ü2 outsider-seat ablation: this member's system prompt is built
+        // WITHOUT project context (question + artefact only). Everyone else
+        // is unaffected — `use_project === project` short-circuits back to
+        // the precomputed `base_system_prompt` when no set is provided.
+        const use_project = no_project_context_members?.has(m.name) ? null : project;
+        let base: string;
         if (plan === undefined) {
-            return base_system_prompt;
+            base =
+                use_project === project
+                    ? base_system_prompt
+                    : system_prompt_for(question.mode, { project: use_project, original_ask });
+        } else {
+            base = advisor_system_prompt(plan.persona_text, { project: use_project, original_ask });
         }
-        return advisor_system_prompt(plan.persona_text, { project, original_ask });
+        const suffix = member_prompt_suffix?.get(m.name);
+        return suffix ? `${base}\n\n${suffix}` : base;
     };
 
     const results: CouncilResponse[] = [];
@@ -1716,6 +1751,21 @@ export interface RenderOptions {
      * slot, prefixed by the visible annotation. Absent/null → byte-identical.
      */
     chairman?: { member: string | null; annotation: string; text: string | null } | null;
+    /**
+     * Ü3 (road-to-council-blind-review Phase 1): when true, the synthesis
+     * template gains the two mandatory chairman fields (Collective blind
+     * spot / One-line verdict). Default `false` → byte-identical.
+     */
+    chairman_fields?: boolean;
+    /**
+     * Ü1 host-path blind render (road-to-council-blind-review Phase 1): when
+     * set, response blocks are headed by their blind label (`## Response A`)
+     * instead of `## <provider> · <model>`, and a de-anonymization map is
+     * appended AFTER the synthesis slot. Only meaningful when no member
+     * chairman ran — the member-chairman path embeds its own de-anon block
+     * directly in `chairman.text`. Default `null` → byte-identical.
+     */
+    blind?: { label_to_source: ReadonlyMap<string, string> } | null;
 }
 
 /**
@@ -1744,6 +1794,15 @@ export function render(responses: CouncilResponse[], opts: RenderOptions = {}):
     const consensus = opts.consensus ?? null;
     const peer_review = opts.peer_review ?? null;
     const explain_confidence = opts.explain_confidence ?? null;
+    // Ü1 host-path blind render: reverse the persisted `label -> provider:model`
+    // map so each response block can look up its own blind label by source.
+    const blind = opts.blind ?? null;
+    const source_to_label =
+        blind !== null
+            ? new Map<string, string>(
+                  Array.from(blind.label_to_source.entries()).map(([label, source]) => [source, label]),
+              )
+            : null;
 
     const blocks: string[] = [];
     const explain =
@@ -1759,7 +1818,8 @@ export function render(responses: CouncilResponse[], opts: RenderOptions = {}):
         blocks.push(_render_consensus(consensus.bucket, explain));
     }
     for (const r of responses) {
-        const header = `## ${r.provider} · ${r.model}`;
+        const blind_label = source_to_label?.get(`${r.provider}:${r.model}`) ?? null;
+        const header = blind_label !== null ? `## ${blind_label}` : `## ${r.provider} · ${r.model}`;
         if (r.error) {
             blocks.push(`${header}\n\n*ERROR:* \`${r.error}\``);
             continue;
@@ -1782,6 +1842,11 @@ export function render(responses: CouncilResponse[], opts: RenderOptions = {}):
         const addendum = peer_review_synthesis_addendum();
         template = template ? `${template}\n${addendum}` : _pyLStrip(addendum);
     }
+    if (opts.chairman_fields === true) {
+        // Ü3: two mandatory trailing sections, composed after any peer-review
+        // addendum so both extensions stack predictably.
+        template = template ? `${template}\n\n${CHAIRMAN_FIELDS_ADDENDUM}` : CHAIRMAN_FIELDS_ADDENDUM;
+    }
     let body: string;
     if (template) {
         body = template;
@@ -1808,6 +1873,11 @@ export function render(responses: CouncilResponse[], opts: RenderOptions = {}):
         blocks.push(render_vote_tally(tally));
     }
     blocks.push(`## Convergence / Divergence\n\n${body}`);
+    if (blind !== null) {
+        // Ü1: de-anonymization AFTER the synthesis slot — blind is only at
+        // decision time, never the archive.
+        blocks.push(render_deanonymization_block('### De-anonymization map', blind.label_to_source));
+    }
     return blocks.join('\n\n---\n\n');
 }
 

package/src/scripts/ai_team/review_gate.ts

@@ -25,16 +25,14 @@
  *      the same `AGENT_CONFIG_NO_EVENTS_LOG` kill-switch, no free-form
  *      content — verdict enum + counter only, PII-excluded by construction).
  *
- * Composition point (documented, not yet manifest-wired): the minimal
- * call-site is `src/scripts/team_review_gate_hook.ts`, a `stop` concern in
- * the dispatcher shape. Claude Code gives sibling Stop hooks no view of the
- * plugin gate's own stdout, so the hook reads the gate verdict from the
- * plugin's persisted job record (`jobs/<id>.json` → `result.rawOutput`,
- * title `Codex Stop Gate Review`) — see `find_latest_gate_transcript`.
- * Registering the concern in `src/scripts/hook_manifest.yaml` (claude/
- * cowork `stop`, after `chat-history`) is the one remaining wiring step;
- * it drags the manifest lint + installer + tests/hooks snapshot surface and
- * is deliberately left to the orchestrator. With
+ * Composition point (manifest-wired): the minimal call-site is
+ * `src/scripts/team_review_gate_hook.ts`, a `stop` concern in the
+ * dispatcher shape, registered in `src/scripts/hook_manifest.yaml` under
+ * `claude.stop` (after `chat-history`). Claude Code gives sibling Stop
+ * hooks no view of the plugin gate's own stdout, so the hook reads the
+ * gate verdict from the plugin's persisted job record (`jobs/<id>.json` →
+ * `result.rawOutput`, title `Codex Stop Gate Review`) — see
+ * `find_latest_gate_transcript`. With
  * `ai_team.review_gate.managed: false` (default) every entry point here is
  * a no-op — byte-identical pre-Phase-4 behavior.
  */

package/src/scripts/ai_team/team_dispatch.ts

@@ -64,6 +64,42 @@ export class TeamDisabledError extends TeamDispatchError {
     }
 }
 
+/**
+ * Thrown by `assert_delegate_allowed` when `ai_team.enabled` is true but the
+ * second opt-in (`ai_team.allow_delegate`) is not. `/team delegate` is the
+ * only wrapper that hands WRITE access to the second model, so it is
+ * double-gated; `enabled: true` alone is never delegate authorization.
+ */
+export class TeamDelegateDisabledError extends TeamDispatchError {
+    constructor() {
+        super(
+            '`/team delegate` is disabled (`ai_team.allow_delegate: false`, the shipped ' +
+                'default). It is the only team-mode wrapper that hands write access to ' +
+                'the second model, so it needs its own opt-in: set both ' +
+                '`ai_team.enabled: true` and `ai_team.allow_delegate: true` in ' +
+                '`.agent-settings.yml` — see docs/contracts/ai-team-config.md.',
+        );
+        this.name = 'TeamDelegateDisabledError';
+    }
+}
+
+/**
+ * Deterministic mirror of the `/team delegate` double gate: throws
+ * `TeamDisabledError` unless `ai_team.enabled`, then
+ * `TeamDelegateDisabledError` unless `ai_team.allow_delegate`. The command
+ * doc's prose gates instruct the agent; this guard is the machine-checkable
+ * contract (`--delegate-gate` CLI mode) tests pin against.
+ */
+export function assert_delegate_allowed(config?: AiTeamConfig, cwd?: string | null): void {
+    const cfg = config ?? load_ai_team_config({ cwd: cwd ?? null });
+    if (!cfg.enabled) {
+        throw new TeamDisabledError();
+    }
+    if (!cfg.allow_delegate) {
+        throw new TeamDelegateDisabledError();
+    }
+}
+
 // ── repo-context bundle (READ-ONLY) ─────────────────────────────────────
 
 /**
@@ -572,6 +608,18 @@ export function run_team_review(opts: RunTeamReviewOptions = {}): TeamReviewRunR
 // ── CLI entry ───────────────────────────────────────────────────────────
 
 function _main(argv: string[]): number {
+    if (argv.includes('--delegate-gate')) {
+        try {
+            assert_delegate_allowed();
+            return 0;
+        } catch (exc) {
+            if (exc instanceof TeamDispatchError) {
+                process.stderr.write(`${exc.message}\n`);
+                return 2;
+            }
+            throw exc;
+        }
+    }
     const manual = argv.includes('--manual');
     try {
         const result = run_team_review({ manual });

package/src/scripts/audit_initial_context.ts

@@ -81,7 +81,7 @@ export const BUDGETS: Record<string, number | null> = {
     'rules.gpt': null,
     'skill_catalog.gpt': 12_500, // always-scanned skill descriptions (skills_core_source, 258); current ~10,999
     'command_catalog.gpt': 5_800, // always-scanned command catalog; current ~5,005
-    'mcp_schemas.gpt': 4_250, // per-connected-client MCP tool schemas; current ~3,694 after the council-gated run_tests exec pilot (598a8a49f) — re-anchored current + ~15% per this cap's own policy
+    'mcp_schemas.gpt': 5_570, // per-connected-client MCP tool schemas; current ~4,839 after Phase 3 of road-to-credible-install (stub-honesty description marker on 12 stubs + readOnlyHint annotations on 19 implemented tools) — re-anchored current + ~15% per this cap's own policy
 };
 
 /**