@event4u/agent-config 16.2.0 → 16.4.0

package/src/scripts/schemas/agent-settings.schema.json

@@ -11,17 +11,6 @@
       "enum": ["minimal", "balanced", "full", "custom"],
       "description": "Rule-tier loading footprint. See docs/contracts/cost-profile-defaults.md and docs/contracts/rule-router.md. NOT a memory or model lever."
     },
-    "memory": {
-      "type": "object",
-      "additionalProperties": true,
-      "properties": {
-        "cadence": {
-          "type": "string",
-          "enum": ["auto", "always", "never"],
-          "description": "Cadence of the 🧠 memory-visibility line. See docs/contracts/memory-visibility-v1.md. Owns its own key since the 2026-06-01 untangle; previously collided with rule_loading_tier."
-        }
-      }
-    },
     "model": {
       "type": "object",
       "additionalProperties": true,
@@ -79,25 +68,34 @@
         }
       }
     },
-    "design": {
+    "git": {
       "type": "object",
       "additionalProperties": true,
       "properties": {
-        "fidelity_mode": {
+        "commit_format": {
           "type": "string",
-          "enum": ["strict", "structural", "hard-floor"],
-          "description": "How strictly the agent must follow a user-provided prototype / mockup / design system. Consumed by the design-fidelity rule. strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous."
+          "enum": ["ticket-scope", "ticket-conventional"],
+          "description": "Where a ticket id goes in a commit subject. ticket-scope (default) = `feat(DEV-1234): …`; ticket-conventional = `DEV-1234 feat(area): …`, a ticket is never a scope."
+        },
+        "branch_pattern": {
+          "type": "string",
+          "description": "Shape of a branch name the agent creates. Placeholders {type}, {ticket}, {slug}. Default {type}/{slug}."
+        },
+        "update_strategy": {
+          "type": "string",
+          "enum": ["merge", "rebase"],
+          "description": "How a feature branch is brought up to date with its base. merge (default) = merge the base in; rebase = rebase onto origin/<base> and push with --force-with-lease, still asked for each time per git-history-discipline."
         }
       }
     },
-    "consistency": {
+    "design": {
       "type": "object",
       "additionalProperties": true,
       "properties": {
-        "cross_source": {
+        "fidelity_mode": {
           "type": "string",
-          "enum": ["on", "auto", "off"],
-          "description": "Consumed by the cross-source-consistency rule. When the agent works from multiple sources (ticket text, an attached image/mockup, the spec, the codebase) it checks them against each other and asks before proceeding on a discrepancy. on (default) = surface every real cross-source contradiction / silent-scope-expansion as one question; auto = surface only high-confidence contradictions, state low-confidence as an assumption; off = no cross-source checking."
+          "enum": ["strict", "structural", "hard-floor"],
+          "description": "How strictly the agent must follow a user-provided prototype / mockup / design system. Consumed by the design-fidelity rule. strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous."
         }
       }
     },
@@ -158,18 +156,6 @@
         }
       }
     },
-    "tokens": {
-      "type": "object",
-      "additionalProperties": true,
-      "description": "Token-spend governance for skills marked token_budget_class: rich. See token-budget-discipline rule.",
-      "properties": {
-        "rich_skills": {
-          "type": "string",
-          "enum": ["on", "ask", "off"],
-          "description": "Controls whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak and thin-projector trimming). on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask the user once per session before loading."
-        }
-      }
-    },
     "commands": {
       "type": "object",
       "additionalProperties": true,

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

@@ -306,7 +306,7 @@
     },
     "auto_detect": {
       "type": "boolean",
-      "description": "6.1.0 orchestrator auto-detection opt-in (Step 1, non-interactive-contract). When true, the orchestrator auto-detects its sub-command per the confidence-tiered detection table instead of always showing the menu, honoring the non-interactive-contract (TTY/CI detection, --yes/--json, abort schemas). Per-orchestrator kill-switch: set false to always show the menu; overridable globally via commands.auto_detect in .agent-settings.yml and per-invocation via --no-auto-detect. Only orchestrators (type: orchestrator) carry it."
+      "description": "6.1.0 orchestrator auto-detection opt-in (Step 1, non-interactive-contract). When true, the orchestrator auto-detects its sub-command per the confidence-tiered detection table instead of always showing the menu, honoring the non-interactive-contract (TTY/CI detection, --yes/--json, abort schemas). Per-orchestrator kill-switch: set false to always show the menu; per-invocation override via --no-auto-detect (there is no global settings switch). Only orchestrators (type: orchestrator) carry it."
     }
   }
 }

package/src/scripts/schemas/review-findings.schema.json

@@ -111,9 +111,10 @@
               "open",
               "fixed",
               "accepted_risk",
-              "false_positive"
+              "false_positive",
+              "still_open"
             ],
-            "description": "Disposition. `fixed` / `false_positive` / `accepted_risk` are the three terminal states check_finding_dispositions accepts; `open` is the initial state. NOTE the underscore spelling — the Markdown track writes `accepted-risk` with a hyphen in its Status cell, and the two vocabularies are deliberately not unified here: renaming either would break committed artefacts on that track."
+            "description": "Disposition. `fixed` / `false_positive` / `accepted_risk` are the three terminal states check_finding_dispositions accepts ON A BLOCKING ROW; `open` is the initial state, meaning nobody has looked yet. `still_open` is a fourth TERMINAL state: a row somebody re-read against a named head, confirmed as a real unfixed issue, and recorded as such. It is deliberately distinct from `open`, which the two look identical to a reader checking only for a non-empty field while being opposites — nobody looked, versus somebody looked and this is the answer. `check_finding_dispositions.TERMINAL_STATUSES` carries all four and `DISPOSITION_STATUSES` only the first three, so a BLOCKING row marked `still_open` reports as an unknown status and keeps the gate red, which is the behaviour a blocking finding that is still open should have. NOTE the underscore spelling — the Markdown track writes `accepted-risk` with a hyphen in its Status cell, and the two vocabularies are deliberately not unified here: renaming either would break committed artefacts on that track."
           },
           "rationale": {
             "type": "string",

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

@@ -212,6 +212,11 @@
       },
       "description": "What mechanically enforces this rule. `validator:<script>` and `test:<path>` must resolve on disk AND be wired into a taskfile, workflow, or the hook manifest — a script that exists but runs nowhere resolves to unwired, not covered. `hook:<name>` must be registered in hook_manifest.yaml with fail_closed: true; a hook that never blocks is `observer:`, not `validator:`. `instruction-only: <reason>` declares an honestly model-carried obligation and is counted as a recorded gap — the reason is MANDATORY in the pattern, because a bare marker is a claim with no triage record behind it and resolves to `missing`, which the --check ratchet reds on. The bare `none` spelling it replaces stays legal for exactly one reason: `non-destructive-by-default` still carries it and is a kernel rule that block_kernel_rule_writes denies agent writes to, so retiring the value outright would make a CI-green tree unreachable for any agent. Resolved, not trusted, by check_enforcement_coverage.ts."
     },
+    "consequence_class": {
+      "type": "string",
+      "enum": ["irreversible-external", "security-boundary", "authority-bypass"],
+      "description": "Which clause of the high-consequence criterion this rule meets, declared only by rules that meet one (road-to-rule-laws-that-can-stand Phase 2). THE CRITERION, and it is meant to be applied by reading the rule's own law section rather than its name: a rule is high-consequence when violating the obligation its law states would (a) `irreversible-external` \u2014 perform an action that leaves this repository and that this agent cannot undo: a deploy, a published egress, a paid render, a rewrite of published history, a destroyed record; or (b) `security-boundary` \u2014 cross a security or data-exposure boundary: authorization, secrets, private or personal data, confidentiality, or untrusted content reaching a privileged path; or (c) `authority-bypass` \u2014 take, or let the agent take, a decision reserved to the user, the owner, or an independent evaluator. A rule whose violation costs quality, tokens, consistency, consistency of style, or rework is NOT high-consequence however important it is \u2014 that reading is what makes the class a measurement rather than a list of favourites. Exactly one clause per rule: where two apply, the declared one is the clause the rule's own law text names. The class is what the criterion produces: every member, every near-miss considered and rejected with its reason, and every member whose law cannot yet stand in a stub are all recorded in src/config/rule-consequence-class.json and checked by tests/scripts/rule_consequence_class.test.ts. Consumed by project_thin_rules, which ships a class member as a stub plus its own law section, byte-copied and digest-checked."
+    },
     "obligation_frequency": {
       "type": "string",
       "enum": ["per-edit", "per-turn", "per-task", "per-session", "per-event", "per-commit", "per-file-write", "none"],

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

@@ -505,7 +505,7 @@
         "standard",
         "rich"
       ],
-      "description": "Token-cost class for this skill. `lean` (default): subject to telegraph-speak condensation and thin-projector trimming; optimize for <500 tokens. `standard`: balanced guidance, normal condensation. `rich`: exempt from telegraph-speak and thin-projector trimming; detailed examples preserved; eager-load eligible; ≤15% of skills in a suite may be `rich` (CI-enforced). A `rich` skill MUST carry a '## Why this skill is rich' section explaining the irreducible complexity that makes condensation harmful. Governed by `token-budget-discipline` rule + `tokens.rich_skills` consumer setting. See docs/guidelines/token-budget-governance.md."
+      "description": "Token-cost class for this skill. `lean` (default): subject to telegraph-speak condensation and thin-projector trimming; optimize for <500 tokens. `standard`: balanced guidance, normal condensation. `rich`: exempt from telegraph-speak and thin-projector trimming; detailed examples preserved; eager-load eligible; ≤15% of skills in a suite may be `rich` (CI-enforced). A `rich` skill MUST carry a '## Why this skill is rich' section explaining the irreducible complexity that makes condensation harmful. Governed by the `token-budget-discipline` rule; rich skills always load in full. See docs/guidelines/token-budget-governance.md."
     },
     "parallelizable": {
       "type": "string",

package/src/scripts/self_review_gate.ts

@@ -34,7 +34,13 @@ import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { AnthropicClient, load_anthropic_key } from './ai_council/clients.js';
+import { CLI_CONSUMER_SELF_REVIEW } from './ai_council/cli_call_budget.js';
+import {
+    AnthropicClient,
+    AnthropicCliClient,
+    type ExternalAIClient,
+    load_anthropic_key,
+} from './ai_council/clients.js';
 import { independenceFields } from './_lib/review_independence.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -110,12 +116,30 @@ export function gateVerdict(findings: readonly Finding[], opts: { enforce: boole
 const SKIP_PREFIXES = ['dist/agent-src/', '.augment/', '.claude/', '.cursor/', '.clinerules/'];
 const SKIP_EXACT = new Set(['.windsurfrules', 'GEMINI.md', 'package-lock.json']);
 
+/**
+ * Review artefacts, `.review-input/` copies included: a copy of a diff that was
+ * already reviewed. The R2 reviewer excludes the same tree
+ * (`REVIEW_SCOPE_EXCLUDES` in `dispatch_r2_reviewer.ts`); here they used to
+ * compete for `MAX_REVIEW_CHUNKS` — 154 of 16.3.0's 603 unreviewed paths sat
+ * under it. Counted separately in the coverage record, never as unreviewed.
+ */
+export const REVIEW_COPY_PREFIX = 'agents/evidence/reviews/';
+
+export function isReviewCopyPath(p: string): boolean {
+    return p.startsWith(REVIEW_COPY_PREFIX);
+}
+
 export function isReviewablePath(p: string): boolean {
     if (SKIP_EXACT.has(p)) return false;
+    if (isReviewCopyPath(p)) return false;
     return !SKIP_PREFIXES.some((pre) => p.startsWith(pre));
 }
 
 function changedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
+    return allChangedFiles(baseRef, cwd).filter(isReviewablePath);
+}
+
+function allChangedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
     // `-c core.quotePath=false`: by default git renders a non-ASCII path as an
     // escaped, QUOTED string (`"gr\303\274e.ts"`), which then matches no
     // pathspec when fed back to `git diff`. The file was silently skipped by
@@ -132,8 +156,7 @@ function changedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
     return (r.stdout ?? '')
         .split('\n')
         .map((s) => s.trim())
-        .filter(Boolean)
-        .filter(isReviewablePath);
+        .filter(Boolean);
 }
 
 /**
@@ -752,6 +775,8 @@ export interface ReviewPlan {
     requests: number;
     /** Files no request will carry, with the reason. */
     unreviewed: { path: string; reason: string }[];
+    /** Changed paths under `REVIEW_COPY_PREFIX` — copies of a reviewed diff, sent to no request. */
+    reviewCopies: string[];
     promptChars: number;
     note: string;
     escalation: string[];
@@ -781,6 +806,7 @@ export function buildPlan(baseRef: string, cwd: string = REPO_ROOT): ReviewPlan
     }
 
     const files = analysisBase === baseRef ? packagingFiles : changedFiles(analysisBase, cwd);
+    const reviewCopies = allChangedFiles(analysisBase, cwd).filter(isReviewCopyPath);
     const diff = diffText(analysisBase, files, cwd);
     const escalation = escalationReasons(files, changedLineCount(analysisBase, files, cwd));
     const systemPrompt = buildSystemPrompt(release, baseRef);
@@ -804,6 +830,7 @@ export function buildPlan(baseRef: string, cwd: string = REPO_ROOT): ReviewPlan
         facts,
         requests: partition.chunks.length,
         unreviewed: partition.unreviewed,
+        reviewCopies,
         skills: [...REVIEW_SKILLS],
         files,
         analysisBase,
@@ -898,6 +925,12 @@ export function coverageBlock(coverage?: ReviewCoverage): string {
         `\n\n**Coverage.** ${String(coverage.chunks)} request(s) over ` +
             `${String(coverage.filesReviewed)} of ${String(coverage.filesTotal)} changed file(s).`,
     ];
+    if ((coverage.reviewCopies ?? 0) > 0) {
+        parts.push(
+            ` ${String(coverage.reviewCopies)} further path(s) under \`${REVIEW_COPY_PREFIX}\` are ` +
+                'copies of an already-reviewed diff and were not re-read.',
+        );
+    }
     if (coverage.unreviewed.length > 0) {
         parts.push(
             ` **NOT reviewed (${String(coverage.unreviewed.length)}):**\n` +
@@ -921,6 +954,12 @@ export interface ReviewCoverage {
     /** Files the span changed, so the reader sees the fraction, not a bare count. */
     filesTotal: number;
     unreviewed: { path: string; reason: string }[];
+    /**
+     * Changed paths under `REVIEW_COPY_PREFIX`, not re-read because each is a
+     * copy of a diff already reviewed. Neither reviewed nor unreviewed, and not
+     * in `filesTotal`. Optional: a record written before this field has none.
+     */
+    reviewCopies?: number;
 }
 
 export function renderReview(findings: Finding[], enforce: boolean, escalation: readonly string[] = [], coverage?: ReviewCoverage): string {
@@ -1012,6 +1051,49 @@ function resolveKey(): string | null {
     }
 }
 
+/** The transport a reviewer was reached on, for the run's own report. */
+interface Reviewer {
+    client: ExternalAIClient;
+    transport: 'cli' | 'api';
+    how: string;
+}
+
+/**
+ * Resolve the review client CLI-FIRST — the subscription transport before the
+ * metered one, which is the ordering the rest of this suite already uses for
+ * coding work and which the council has used since it grew a `mode: cli`.
+ *
+ * The ordering is not a preference. An API key is a METERED resource with a
+ * balance that runs out, and when it does the gate reports NEUTRAL — a release
+ * then carries no review at all. That is not hypothetical: it is how 16.3.0
+ * stalled, with six chunks returning `credit balance is too low` and the
+ * release step refusing for want of a findings artefact. A vendor CLI backed by
+ * a subscription has no balance to exhaust, so trying it first removes the one
+ * failure mode that has actually produced an unreviewed release here.
+ *
+ * `AnthropicCliClient`'s constructor THROWS when `claude` is not on PATH, which
+ * is the probe: a hosted GitHub runner has no vendor CLI and falls straight
+ * through to the API transport, so this change costs CI nothing and buys every
+ * local and self-hosted run a free review. The catch is deliberately broad —
+ * anything that goes wrong reaching for the CLI resolves to the API path rather
+ * than to a NEUTRAL, because a reviewed release beats a diagnosed one.
+ *
+ * Calls book against `CLI_CONSUMER_SELF_REVIEW` so the daily CLI counter can
+ * tell a review apart from a council round; without the attribution the gate's
+ * six chunks would read as unexplained council spend.
+ */
+function resolveReviewer(): Reviewer | null {
+    try {
+        const client = new AnthropicCliClient({ consumer: CLI_CONSUMER_SELF_REVIEW });
+        return { client, transport: 'cli', how: `vendor CLI (${client.binary}), subscription` };
+    } catch {
+        // No `claude` on PATH, or the client refused to construct. Fall through.
+    }
+    const key = resolveKey();
+    if (!key) return null;
+    return { client: new AnthropicClient({ api_key: key }), transport: 'api', how: 'ANTHROPIC_API_KEY' };
+}
+
 // ── CLI ───────────────────────────────────────────────────────────────
 export function main(argv: string[]): 0 | 2 {
     const dryRun = argv.includes('--dry-run');
@@ -1040,6 +1122,9 @@ export function main(argv: string[]): 0 | 2 {
                       `packaging diff ${plan.release.packagingFiles.length} file(s))\n`
                     : '') +
                 `  files:  ${plan.files.length}\n` +
+                (plan.reviewCopies.length > 0
+                    ? `  review copies (not re-read): ${String(plan.reviewCopies.length)}\n`
+                    : '') +
                 `  calls:  ${plan.requests} (budget ${String(PROMPT_BUDGET_CHARS)} chars/request, ` +
                 `ceiling ${String(MAX_REVIEW_CHUNKS)})\n` +
                 (plan.unreviewed.length > 0
@@ -1087,22 +1172,28 @@ export function main(argv: string[]): 0 | 2 {
         return 0;
     }
 
-    const key = resolveKey();
-    if (!key) {
+    const reviewer = resolveReviewer();
+    if (!reviewer) {
         // Explicit NEUTRAL state — never a bare green that reads as "reviewed".
+        // BOTH transports are named, because naming only the API one is what
+        // made the CLI path invisible: an operator reading this warning set the
+        // secret and never learned a logged-in `claude` would also have served.
         process.stdout.write(
-            '::warning::self-review-gate NEUTRAL — no ANTHROPIC_API_KEY configured, NOTHING was reviewed. ' +
-                'Set the repo secret to enable the live dogfooded review.\n',
+            '::warning::self-review-gate NEUTRAL — no reviewer reachable (no `claude` CLI on PATH, ' +
+                'no ANTHROPIC_API_KEY), NOTHING was reviewed. Log in to the vendor CLI or set the ' +
+                'repo secret to enable the live dogfooded review.\n',
         );
         const summary = process.env.GITHUB_STEP_SUMMARY;
         if (summary) {
             appendFileSync(
                 summary,
-                '### Self-review gate: NEUTRAL\n\nNo `ANTHROPIC_API_KEY` secret — nothing was reviewed. This is not a pass.\n',
+                '### Self-review gate: NEUTRAL\n\nNo reviewer reachable — neither the `claude` CLI ' +
+                    '(subscription) nor `ANTHROPIC_API_KEY` (metered). Nothing was reviewed. This is not a pass.\n',
             );
         }
         return 0;
     }
+    process.stdout.write(`::notice::self-review-gate — transport: ${reviewer.transport} (${reviewer.how}).\n`);
 
     // Belt-and-suspenders: the WHOLE live path is wrapped so that ANYTHING going
     // wrong — no API credit / balance (HTTP 402), rate-limit (429), network error,
@@ -1111,7 +1202,7 @@ export function main(argv: string[]): 0 | 2 {
     // gate is advisory by design. (Only an --enforce run with real blocking
     // findings returns 2 — an error is not a finding.)
     try {
-        const client = new AnthropicClient({ api_key: key });
+        const client = reviewer.client;
         const systemPrompt = buildSystemPrompt(plan.release, baseRef);
         const partition = plan.partition;
 
@@ -1187,6 +1278,7 @@ export function main(argv: string[]): 0 | 2 {
             filesReviewed: filesRead,
             filesTotal: plan.files.length,
             unreviewed,
+            reviewCopies: plan.reviewCopies.length,
         };
         // Ground-truth pass, ONCE, before anything reads the finding set. A
         // deletion claim the range and the tree both disprove is annotated