@phuetz/code-buddy 1.6.0 → 2.0.0

package/dist/review/llm-client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default reviewer client — resolves a real LLM from the active pool for
+ * `full`-mode reviews when the caller didn't inject one (the apply_patch
+ * bridge). Strong-model name heuristic, dead models skipped via the
+ * scoreboard's trailing-failure streak (same discipline as the council
+ * judge). Lazy imports keep this graph out of the tool's off path; any
+ * failure → null → the engine fails closed.
+ *
+ * Pinning: `CODEBUDDY_DIFF_REVIEW_MODEL` wins, then `GROK_MODEL` if it is in
+ * the pool. Local strong models (qwen3.5+/devstral/…) beat a cloud gateway
+ * so `CODEBUDDY_DIFF_REVIEW=full` works on an Ollama-only box.
+ *
+ * @module review/llm-client
+ */
+import type { CouncilChatClient } from '../council/types.js';
+import type { ActiveLlmModelPoolEntry } from '../providers/active-llm-model-pool.js';
+/**
+ * Cloud frontier names plus local models that reliably emit the JSON verdict
+ * the gate requires. Deliberately excludes tiny chat-only tags (`llama3`,
+ * `gemma*`, `qwen3:4b`, embedders) — those hallucinate prose and would
+ * fail-closed every review.
+ */
+export declare const STRONG_REVIEWER_PATTERN: RegExp;
+export declare function isStrongReviewerModel(model: string): boolean;
+/**
+ * Pure pool picker (no I/O) — the default full-mode reviewer.
+ * `env` is injectable so tests don't mutate process.env.
+ */
+export declare function pickReviewerPoolEntry(pool: ActiveLlmModelPoolEntry[], env?: NodeJS.ProcessEnv, consecutiveRecentFailures?: (model: string) => number): ActiveLlmModelPoolEntry | null;
+export declare function resolveDefaultReviewClient(): Promise<CouncilChatClient | null>;

package/dist/review/llm-client.js

@@ -0,0 +1,98 @@
+/**
+ * Default reviewer client — resolves a real LLM from the active pool for
+ * `full`-mode reviews when the caller didn't inject one (the apply_patch
+ * bridge). Strong-model name heuristic, dead models skipped via the
+ * scoreboard's trailing-failure streak (same discipline as the council
+ * judge). Lazy imports keep this graph out of the tool's off path; any
+ * failure → null → the engine fails closed.
+ *
+ * Pinning: `CODEBUDDY_DIFF_REVIEW_MODEL` wins, then `GROK_MODEL` if it is in
+ * the pool. Local strong models (qwen3.5+/devstral/…) beat a cloud gateway
+ * so `CODEBUDDY_DIFF_REVIEW=full` works on an Ollama-only box.
+ *
+ * @module review/llm-client
+ */
+/**
+ * Cloud frontier names plus local models that reliably emit the JSON verdict
+ * the gate requires. Deliberately excludes tiny chat-only tags (`llama3`,
+ * `gemma*`, `qwen3:4b`, embedders) — those hallucinate prose and would
+ * fail-closed every review.
+ */
+export const STRONG_REVIEWER_PATTERN = /gpt-5|opus|sonnet|fable|gemini|grok-[34]|qwen3\.[5-9]|devstral|glm-4\.5|glm-5|kimi-k[23]|nemotron-3|deepseek-r1|deepseek-v3/;
+const DEAD_AFTER_FAILURES = 2;
+export function isStrongReviewerModel(model) {
+    return STRONG_REVIEWER_PATTERN.test(model.toLowerCase());
+}
+function matchPoolModel(pool, wanted) {
+    const needle = wanted.toLowerCase();
+    return (pool.find((p) => p.model.toLowerCase() === needle) ??
+        pool.find((p) => p.model.toLowerCase().startsWith(needle)) ??
+        pool.find((p) => p.model.toLowerCase().includes(needle)));
+}
+function isAlive(entry, consecutiveRecentFailures) {
+    return Boolean(entry.apiKey) && consecutiveRecentFailures(entry.model) < DEAD_AFTER_FAILURES;
+}
+/**
+ * Pure pool picker (no I/O) — the default full-mode reviewer.
+ * `env` is injectable so tests don't mutate process.env.
+ */
+export function pickReviewerPoolEntry(pool, env = process.env, consecutiveRecentFailures = () => 0) {
+    const alive = pool.filter((p) => isAlive(p, consecutiveRecentFailures));
+    const pin = env.CODEBUDDY_DIFF_REVIEW_MODEL?.trim();
+    if (pin) {
+        const pinned = matchPoolModel(alive, pin);
+        if (pinned)
+            return pinned;
+        if (consecutiveRecentFailures(pin) < DEAD_AFTER_FAILURES) {
+            const donor = alive.find((p) => p.provider === 'ollama') ?? alive.find((p) => p.egress === 'local');
+            if (donor)
+                return { ...donor, model: pin };
+        }
+    }
+    const grok = env.GROK_MODEL?.trim();
+    if (grok) {
+        const named = matchPoolModel(alive, grok);
+        if (named)
+            return named;
+    }
+    const strongLocal = alive.find((p) => p.egress === 'local' && isStrongReviewerModel(p.model));
+    if (strongLocal)
+        return strongLocal;
+    return alive.find((p) => isStrongReviewerModel(p.model)) ?? null;
+}
+export async function resolveDefaultReviewClient() {
+    try {
+        const [{ listActiveLlmModelPool }, { CodeBuddyClient }, { getModelScoreboard }] = await Promise.all([
+            import('../providers/active-llm-model-pool.js'),
+            import('../codebuddy/client.js'),
+            import('../fleet/model-scoreboard.js'),
+        ]);
+        const pool = await listActiveLlmModelPool();
+        const scoreboard = getModelScoreboard();
+        const pick = pickReviewerPoolEntry(pool, process.env, (model) => scoreboard.consecutiveRecentFailures(model));
+        if (!pick?.apiKey)
+            return null;
+        const raw = new CodeBuddyClient(pick.apiKey, pick.model, pick.baseURL);
+        return {
+            async chat(messages) {
+                // Cap output: qwen3.8's model default is 16 384 tokens, which lets
+                // hidden thinking fill the review timeout without ever emitting JSON.
+                // Temperature 0 + no cross-provider fallback keep the verdict local.
+                const resp = await raw.chat(messages, [], {
+                    temperature: 0,
+                    maxTokens: 1024,
+                    disableProviderFallback: true,
+                });
+                return {
+                    content: resp?.choices?.[0]?.message?.content ?? '',
+                    promptTokens: resp?.usage?.prompt_tokens ?? 0,
+                    totalTokens: resp?.usage?.total_tokens ?? 0,
+                };
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=llm-client.js.map

package/dist/review/llm-reviewer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LLM reviewers — lens-specialised structured review of a proposed diff.
+ *
+ * Same discipline as the council judge: strict-JSON verdict, two-stage parse
+ * (pure JSON then salvage), and FAIL-CLOSED on anything unreliable — a
+ * reviewer that times out, errors or answers prose yields a `reject` report
+ * flagged `failClosed`, never a silent pass. Lenses run one after another
+ * (a local runtime cannot overlap generations) and are deliberately diverse
+ * (correctness vs security) — diversity catches failure modes redundancy can't.
+ *
+ * @module review/llm-reviewer
+ */
+import type { CouncilChatClient } from '../council/types.js';
+import type { ProposedDiff, ReviewLens, ReviewerReport } from './types.js';
+export declare const DEFAULT_REVIEW_LENSES: ReviewLens[];
+export declare function reviewWithLens(client: CouncilChatClient, lens: ReviewLens, diff: ProposedDiff, timeoutMs: number): Promise<ReviewerReport>;

package/dist/review/llm-reviewer.js

@@ -0,0 +1,122 @@
+/**
+ * LLM reviewers — lens-specialised structured review of a proposed diff.
+ *
+ * Same discipline as the council judge: strict-JSON verdict, two-stage parse
+ * (pure JSON then salvage), and FAIL-CLOSED on anything unreliable — a
+ * reviewer that times out, errors or answers prose yields a `reject` report
+ * flagged `failClosed`, never a silent pass. Lenses run one after another
+ * (a local runtime cannot overlap generations) and are deliberately diverse
+ * (correctness vs security) — diversity catches failure modes redundancy can't.
+ *
+ * @module review/llm-reviewer
+ */
+import { withTimeout } from '../council/with-timeout.js';
+import { extractJsonObject } from '../utils/json-salvage.js';
+import { renderUnifiedPreview } from './diff-model.js';
+export const DEFAULT_REVIEW_LENSES = [
+    {
+        id: 'correctness',
+        label: 'Correctness reviewer',
+        focus: 'bugs, logic errors, broken invariants and contracts, regressions vs the stated intent, missing edge cases the diff itself introduces',
+    },
+    {
+        id: 'security',
+        label: 'Security reviewer',
+        focus: 'injection (shell/SQL/path), path traversal, unsafe exec/eval, secrets or credentials, data exfiltration, permission widening',
+    },
+];
+const MAX_PREVIEW_CHARS_PER_FILE = 6000;
+const VALID_DECISIONS = new Set(['accept', 'reject', 'annotate']);
+const VALID_SEVERITIES = new Set(['blocker', 'warning', 'suggestion']);
+/** Two-stage strict-JSON parse (shared with the council judge). */
+function extractReviewerJson(text) {
+    return extractJsonObject(text);
+}
+function truncatePreview(text) {
+    if (text.length <= MAX_PREVIEW_CHARS_PER_FILE)
+        return text;
+    return `${text.slice(0, MAX_PREVIEW_CHARS_PER_FILE)}\n...[truncated for review]`;
+}
+function buildReviewPrompt(lens, diff) {
+    const system = `You are the ${lens.label} of Code Buddy's diff-review gate. An agent proposes ` +
+        'a file modification; you decide whether it may be APPLIED. Hunt specifically for: ' +
+        `${lens.focus}. ` +
+        'Rules: judge ONLY what this diff changes (not pre-existing flaws in untouched code); ' +
+        'severity discipline — "blocker" means MUST NOT be applied, "warning" means the ' +
+        'proposer must revise first, "suggestion" never blocks; style nits are suggestions at most; ' +
+        'decision mapping — any blocker → "reject", warnings but no blocker → "annotate", else "accept". ' +
+        'If you cannot review reliably, return decision "reject" with one blocker explaining why. ' +
+        'Respond with STRICT JSON and nothing else: ' +
+        '{"decision":"accept|reject|annotate","annotations":[{"path":"file","line":1,"severity":"blocker|warning|suggestion","message":"...","suggestedFix":"..."}],"why":"one short sentence"}';
+    const previews = diff.files
+        .map((f) => `### ${f.path} (${f.action})\n${truncatePreview(renderUnifiedPreview(f))}`)
+        .join('\n\n');
+    const user = `INTENT of the proposer:\n${diff.intent}\n\nPROPOSED DIFF:\n${previews}\n\nReturn the JSON now.`;
+    return { system, user };
+}
+function normalizeAnnotations(raw, knownPaths) {
+    const out = [];
+    for (const a of raw ?? []) {
+        if (!a || typeof a.message !== 'string' || !a.message.trim())
+            continue;
+        const severity = VALID_SEVERITIES.has(String(a.severity))
+            ? a.severity
+            : 'warning';
+        const path = typeof a.path === 'string' && knownPaths.has(a.path) ? a.path : [...knownPaths][0];
+        out.push({
+            path,
+            ...(Number.isFinite(a.line) && a.line > 0
+                ? { line: Math.floor(a.line) }
+                : {}),
+            severity,
+            message: a.message.trim(),
+            ...(typeof a.suggestedFix === 'string' && a.suggestedFix.trim()
+                ? { suggestedFix: a.suggestedFix.trim() }
+                : {}),
+        });
+    }
+    return out;
+}
+/** Consistency guard: the decision can never be laxer than the annotations. */
+function reconcileDecision(decision, annotations) {
+    if (annotations.some((a) => a.severity === 'blocker'))
+        return 'reject';
+    if (decision === 'accept' && annotations.some((a) => a.severity === 'warning'))
+        return 'annotate';
+    return decision;
+}
+export async function reviewWithLens(client, lens, diff, timeoutMs) {
+    const failClosed = (reason) => ({
+        reviewer: lens.id,
+        decision: 'reject',
+        annotations: [
+            {
+                path: diff.files[0].path,
+                severity: 'blocker',
+                message: `review unavailable (${lens.id}): ${reason} — fail-closed, the diff was NOT applied`,
+            },
+        ],
+        failClosed: true,
+    });
+    const prompt = buildReviewPrompt(lens, diff);
+    let content;
+    try {
+        const resp = await withTimeout(client.chat([
+            { role: 'system', content: prompt.system },
+            { role: 'user', content: prompt.user },
+        ]), timeoutMs, `review:${lens.id}`);
+        content = resp.content;
+    }
+    catch (err) {
+        return failClosed(err instanceof Error ? err.message : String(err));
+    }
+    const json = extractReviewerJson(content);
+    if (!json || !VALID_DECISIONS.has(String(json.decision))) {
+        return failClosed('non-JSON or invalid verdict');
+    }
+    const knownPaths = new Set(diff.files.map((f) => f.path));
+    const annotations = normalizeAnnotations(json.annotations, knownPaths);
+    const decision = reconcileDecision(json.decision, annotations);
+    return { reviewer: lens.id, decision, annotations };
+}
+//# sourceMappingURL=llm-reviewer.js.map

package/dist/review/review-engine.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Review engine — orchestrates the gate: conflicts → static gate → (full
+ * mode) lens reviewers in parallel → fail-closed aggregation → verdict.
+ *
+ * Aggregation is an AND, never a vote: any reviewer reject → reject; any
+ * blocker → reject; any warning/annotate → annotate; else accept. A security
+ * blocker can never be outvoted — this is exactly why the review is a GATE
+ * downstream of the council, not a council member (a member's verdict would
+ * be one voice among N and averaged away).
+ *
+ * Modes (CODEBUDDY_DIFF_REVIEW, default off — repo convention):
+ *  - off    → the gate is bypassed by resolveReviewMode callers.
+ *  - static → deterministic checks only, zero LLM.
+ *  - full   → static + lens reviewers (fail-closed when no client works).
+ *
+ * @module review/review-engine
+ */
+import { type BuildProposedDiffInput } from './diff-model.js';
+import { type ApplyOptions } from './apply-transaction.js';
+import type { ApplyReport, ProposedDiff, ReviewEngineDeps, ReviewMode, ReviewVerdict } from './types.js';
+/** Env gate (injectable for tests), default OFF like every optional subsystem. */
+export declare function resolveReviewMode(env?: NodeJS.ProcessEnv): ReviewMode;
+export declare function reviewProposedDiff(diff: ProposedDiff, deps?: ReviewEngineDeps): Promise<ReviewVerdict>;
+export interface ReviewLedgerRecord {
+    at: string;
+    diffId: string;
+    origin: ProposedDiff['origin'];
+    intent: string;
+    files: string[];
+    mode: ReviewMode;
+    decision: ReviewVerdict['decision'];
+    failClosed: boolean;
+    blockers: number;
+    warnings: number;
+    suggestions: number;
+    applied: boolean;
+    appliedFiles: string[];
+    checkpointId: string | null;
+}
+export declare function buildLedgerRecord(diff: ProposedDiff, verdict: ReviewVerdict, apply: ApplyReport | null): ReviewLedgerRecord;
+export declare function appendReviewRecord(workDir: string, record: ReviewLedgerRecord): void;
+export interface ReviewAndApplyResult {
+    diff: ProposedDiff;
+    verdict: ReviewVerdict;
+    /** null when the verdict forbade any apply attempt. */
+    apply: ApplyReport | null;
+}
+/**
+ * One-call gate for producers: build the diff from full before/after content,
+ * review it, apply it when the verdict allows, and journal the outcome.
+ * `annotate` + atomic mode applies nothing — the caller feeds
+ * `verdict.annotations` back to the proposer for a revision round.
+ */
+export declare function reviewAndApply(input: BuildProposedDiffInput, deps?: ReviewEngineDeps, applyOpts?: ApplyOptions): Promise<ReviewAndApplyResult>;

package/dist/review/revision-loop.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Automatic revision loop — closes the review cycle: a diff that comes back
+ * `annotate` (or rejected on MERIT with actionable blockers) is handed to a
+ * reviser LLM together with the annotations; the revised diff goes through
+ * the SAME gate again, up to a bounded number of rounds.
+ *
+ * Fail-closed at every link: a reviser that times out, answers prose, or
+ * whose output cannot be constrained stops the loop — the caller gets the
+ * last honest verdict, never an unreviewed write. Not revisable by design:
+ * `failClosed` verdicts (nothing to revise from — the review itself was
+ * unavailable) and conflicts (a stale base needs re-proposal against the
+ * current tree, not annotation-fixing).
+ *
+ * Guard rails on the reviser output: it may only touch the ORIGINAL diff's
+ * paths (extra paths are dropped and reported — a revision must narrow, not
+ * expand, the blast radius), and every round is journaled to the audit
+ * ledger by the underlying reviewAndApply.
+ *
+ * @module review/revision-loop
+ */
+import type { CouncilChatClient } from '../council/types.js';
+import { type ReviewAndApplyResult } from './review-engine.js';
+import type { BuildProposedDiffInput, ProposedChangeInput } from './diff-model.js';
+import type { ApplyOptions } from './apply-transaction.js';
+import type { ProposedDiff, ReviewAnnotation, ReviewDecision, ReviewEngineDeps, ReviewVerdict } from './types.js';
+export declare function buildRevisionPrompt(diff: ProposedDiff, verdict: ReviewVerdict): {
+    system: string;
+    user: string;
+};
+export interface RevisionAttempt {
+    changes: ProposedChangeInput[];
+    note: string;
+    /** Paths the reviser tried to add outside the original set (dropped). */
+    droppedPaths: string[];
+}
+/**
+ * Ask the reviser for a corrected change set. Returns null (fail-closed) on
+ * timeout / non-JSON / empty usable output — the loop stops honestly.
+ */
+export declare function reviseProposedDiff(client: CouncilChatClient, diff: ProposedDiff, verdict: ReviewVerdict, timeoutMs?: number): Promise<RevisionAttempt | null>;
+export interface RevisionRound {
+    diffId: string;
+    decision: ReviewDecision;
+    failClosed: boolean;
+    annotations: ReviewAnnotation[];
+    /** Set when this round's verdict triggered a revision that produced the next round. */
+    reviserNote?: string;
+}
+export interface ReviewApplyWithRevisionsResult {
+    /** One entry per review round, in order (≥ 1). */
+    rounds: RevisionRound[];
+    /** The last round's full result (its `apply` reflects the final decision). */
+    final: ReviewAndApplyResult;
+    /** True when at least one revision was attempted. */
+    revised: boolean;
+}
+export interface RevisionLoopOptions {
+    client: CouncilChatClient;
+    maxRounds?: number;
+    timeoutMs?: number;
+}
+/**
+ * reviewAndApply with a bounded automatic revision loop. Every round is
+ * journaled by the underlying gate; the revised intent carries the lineage
+ * (`… (revision N of <original diff id>)`) so the ledger tells the story.
+ */
+export declare function reviewApplyWithRevisions(input: BuildProposedDiffInput, engineDeps: ReviewEngineDeps, applyOpts: ApplyOptions, revision: RevisionLoopOptions): Promise<ReviewApplyWithRevisionsResult>;

package/dist/review/revision-loop.js

@@ -0,0 +1,160 @@
+/**
+ * Automatic revision loop — closes the review cycle: a diff that comes back
+ * `annotate` (or rejected on MERIT with actionable blockers) is handed to a
+ * reviser LLM together with the annotations; the revised diff goes through
+ * the SAME gate again, up to a bounded number of rounds.
+ *
+ * Fail-closed at every link: a reviser that times out, answers prose, or
+ * whose output cannot be constrained stops the loop — the caller gets the
+ * last honest verdict, never an unreviewed write. Not revisable by design:
+ * `failClosed` verdicts (nothing to revise from — the review itself was
+ * unavailable) and conflicts (a stale base needs re-proposal against the
+ * current tree, not annotation-fixing).
+ *
+ * Guard rails on the reviser output: it may only touch the ORIGINAL diff's
+ * paths (extra paths are dropped and reported — a revision must narrow, not
+ * expand, the blast radius), and every round is journaled to the audit
+ * ledger by the underlying reviewAndApply.
+ *
+ * @module review/revision-loop
+ */
+import { withTimeout } from '../council/with-timeout.js';
+import { extractJsonObject } from '../utils/json-salvage.js';
+import { reviewAndApply } from './review-engine.js';
+const DEFAULT_MAX_ROUNDS = 2;
+const DEFAULT_REVISER_TIMEOUT_MS = 90_000;
+/** Beyond this per-file size the reviser must return full content — skip revision instead of truncating. */
+const MAX_REVISABLE_FILE_CHARS = 20_000;
+/** Two-stage strict-JSON parse (shared with judge/reviewers). */
+function extractReviserJson(text) {
+    return extractJsonObject(text);
+}
+export function buildRevisionPrompt(diff, verdict) {
+    const system = 'You are the reviser of Code Buddy\'s diff-review gate. A proposed file modification was ' +
+        'reviewed and came back with annotations; produce a REVISED version that addresses every ' +
+        'blocker and warning while still achieving the original intent. ' +
+        'Rules: change ONLY what the annotations require; keep the rest of each file byte-identical; ' +
+        'you may only touch the files listed below (never add new ones); if an annotation asks to drop ' +
+        'a file from the change, return it with "newContent": "KEEP-BASE". ' +
+        'Return STRICT JSON and nothing else: ' +
+        '{"files":[{"path":"<one of the listed paths>","newContent":"full revised file content, or null to delete, or KEEP-BASE to withdraw the change"}],"note":"one sentence on what you changed"}. ' +
+        'Every listed file must appear in your output.';
+    const annotations = verdict.annotations
+        .filter((a) => a.severity !== 'suggestion')
+        .map((a) => {
+        const anchor = a.line ? `${a.path}:${a.line}` : a.path;
+        const fix = a.suggestedFix ? ` | suggested fix: ${a.suggestedFix}` : '';
+        return `- [${a.severity}] ${anchor} — ${a.message}${fix}`;
+    })
+        .join('\n');
+    const files = diff.files
+        .map((f) => {
+        if (f.newContent === null)
+            return `### ${f.path} (proposed action: DELETE the file)`;
+        return `### ${f.path} (${f.action}) — full proposed content:\n\`\`\`\n${f.newContent}\n\`\`\``;
+    })
+        .join('\n\n');
+    const user = `ORIGINAL INTENT:\n${diff.intent}\n\nREVIEW ANNOTATIONS TO ADDRESS:\n${annotations}\n\n` +
+        `PROPOSED FILES:\n${files}\n\nReturn the revised JSON now.`;
+    return { system, user };
+}
+/**
+ * Ask the reviser for a corrected change set. Returns null (fail-closed) on
+ * timeout / non-JSON / empty usable output — the loop stops honestly.
+ */
+export async function reviseProposedDiff(client, diff, verdict, timeoutMs = DEFAULT_REVISER_TIMEOUT_MS) {
+    if (diff.files.some((f) => (f.newContent?.length ?? 0) > MAX_REVISABLE_FILE_CHARS)) {
+        return null; // full-content revision would risk truncation — fail closed
+    }
+    const prompt = buildRevisionPrompt(diff, verdict);
+    let content;
+    try {
+        const resp = await withTimeout(client.chat([
+            { role: 'system', content: prompt.system },
+            { role: 'user', content: prompt.user },
+        ]), timeoutMs, 'reviser');
+        content = resp.content;
+    }
+    catch {
+        return null;
+    }
+    const json = extractReviserJson(content);
+    if (!json || !Array.isArray(json.files))
+        return null;
+    const allowed = new Map(diff.files.map((f) => [f.path, f]));
+    const changes = [];
+    const droppedPaths = [];
+    const seen = new Set();
+    for (const file of json.files) {
+        if (typeof file?.path !== 'string' || seen.has(file.path))
+            continue;
+        const original = allowed.get(file.path);
+        if (!original) {
+            droppedPaths.push(String(file.path));
+            continue;
+        }
+        seen.add(file.path);
+        if (file.newContent === 'KEEP-BASE')
+            continue; // change withdrawn for this file
+        if (file.newContent === null) {
+            changes.push({ path: file.path, newContent: null });
+        }
+        else if (typeof file.newContent === 'string') {
+            changes.push({ path: file.path, newContent: file.newContent });
+        }
+    }
+    // Files the reviser forgot are carried over unchanged — a partial answer
+    // must not silently drop part of the proposal.
+    for (const original of diff.files) {
+        if (!seen.has(original.path)) {
+            changes.push({ path: original.path, newContent: original.newContent });
+        }
+    }
+    if (changes.length === 0)
+        return null; // everything withdrawn — nothing to re-review
+    return { changes, note: typeof json.note === 'string' ? json.note.trim() : '', droppedPaths };
+}
+function isRevisable(verdict) {
+    if (verdict.failClosed || verdict.conflicts.length > 0)
+        return false;
+    return verdict.decision === 'annotate' || verdict.decision === 'reject';
+}
+/**
+ * reviewAndApply with a bounded automatic revision loop. Every round is
+ * journaled by the underlying gate; the revised intent carries the lineage
+ * (`… (revision N of <original diff id>)`) so the ledger tells the story.
+ */
+export async function reviewApplyWithRevisions(input, engineDeps, applyOpts, revision) {
+    const maxRounds = Math.max(1, revision.maxRounds ?? DEFAULT_MAX_ROUNDS);
+    const rounds = [];
+    let currentInput = input;
+    let result = await reviewAndApply(currentInput, engineDeps, applyOpts);
+    let originalId = null;
+    let revised = false;
+    for (let round = 1;; round++) {
+        const roundRecord = {
+            diffId: result.diff.id,
+            decision: result.verdict.decision,
+            failClosed: result.verdict.failClosed,
+            annotations: result.verdict.annotations,
+        };
+        rounds.push(roundRecord);
+        originalId = originalId ?? result.diff.id;
+        const done = result.verdict.decision === 'accept' || round >= maxRounds || !isRevisable(result.verdict);
+        if (done)
+            break;
+        const attempt = await reviseProposedDiff(revision.client, result.diff, result.verdict, revision.timeoutMs);
+        if (!attempt)
+            break; // reviser failed — stop with the honest verdict
+        revised = true;
+        roundRecord.reviserNote = attempt.note || '(no note)';
+        currentInput = {
+            ...input,
+            intent: `${input.intent} (revision ${round} of ${originalId})`,
+            changes: attempt.changes,
+        };
+        result = await reviewAndApply(currentInput, engineDeps, applyOpts);
+    }
+    return { rounds, final: result, revised };
+}
+//# sourceMappingURL=revision-loop.js.map

package/dist/review/static-gate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Static gate — deterministic, zero-LLM checks every proposed diff passes
+ * FIRST. Cheap, reproducible, and unbluffable: a diff that fails here is
+ * rejected without spending a single reviewer token.
+ *
+ * Checks: omission placeholders (reuses the text-editor's detector — the
+ * "// ... rest of code" class of truncation), introduced secrets, protected
+ * paths, diff size caps, suspicious massive shrink, and no-op changes.
+ *
+ * @module review/static-gate
+ */
+import type { ProposedDiff, ReviewerReport, StaticGateOptions } from './types.js';
+export declare function runStaticGate(diff: ProposedDiff, opts?: StaticGateOptions): ReviewerReport;