audit-tools 0.28.0

package/dist/shared/quota/types.d.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export declare const LimitSourceSchema: z.ZodEnum<["explicit_config", "discovered_capability", "cli_flags", "provider_default", "learned", "default"]>;
+export type LimitSource = z.infer<typeof LimitSourceSchema>;
+export declare const LimitConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
+export type LimitConfidence = z.infer<typeof LimitConfidenceSchema>;
+export declare const HostConcurrencyLimitSourceSchema: z.ZodEnum<["cli_flags", "host_reported", "session_config", "environment"]>;
+export type HostConcurrencyLimitSource = z.infer<typeof HostConcurrencyLimitSourceSchema>;
+export declare const HostConcurrencyLimitSchema: z.ZodObject<{
+    active_subagents: z.ZodNumber;
+    source: z.ZodEnum<["cli_flags", "host_reported", "session_config", "environment"]>;
+    description: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    source: "cli_flags" | "host_reported" | "session_config" | "environment";
+    active_subagents: number;
+    description: string;
+}, {
+    source: "cli_flags" | "host_reported" | "session_config" | "environment";
+    active_subagents: number;
+    description: string;
+}>;
+export type HostConcurrencyLimit = z.infer<typeof HostConcurrencyLimitSchema>;
+export declare const ResolvedLimitsSchema: z.ZodObject<{
+    context_tokens: z.ZodNumber;
+    output_tokens: z.ZodNumber;
+    requests_per_minute: z.ZodNullable<z.ZodNumber>;
+    input_tokens_per_minute: z.ZodNullable<z.ZodNumber>;
+    output_tokens_per_minute: z.ZodNullable<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    requests_per_minute: number | null;
+    input_tokens_per_minute: number | null;
+    context_tokens: number;
+    output_tokens: number;
+    output_tokens_per_minute: number | null;
+}, {
+    requests_per_minute: number | null;
+    input_tokens_per_minute: number | null;
+    context_tokens: number;
+    output_tokens: number;
+    output_tokens_per_minute: number | null;
+}>;
+export type ResolvedLimits = z.infer<typeof ResolvedLimitsSchema>;
+export interface ConcurrencyBucket {
+    success_weight: number;
+    failure_weight: number;
+}
+export interface QuotaStateEntry {
+    updated_at: string;
+    buckets: Record<string, ConcurrencyBucket>;
+    cooldown_until: string | null;
+    last_429_at: string | null;
+    consecutive_429_count?: number;
+}
+export interface QuotaState {
+    version: 1 | 2;
+    entries: Record<string, QuotaStateEntry>;
+}
+/**
+ * Identifies which cap actually bound the final wave size, so an operator can
+ * see *why* a wave was throttled (or that nothing throttled it) without
+ * re-deriving the decision. Set by `scheduleWave`; logged by callers that hold a
+ * RunLogger as a `kind:"scope"` event.
+ */
+export declare const WaveBindingCapSchema: z.ZodEnum<["rpm", "tpm", "learned", "fallback", "first_contact", "cooldown", "host_concurrency", "none"]>;
+export type WaveBindingCap = z.infer<typeof WaveBindingCapSchema>;
+export interface WaveSchedule {
+    max_concurrent: number;
+    estimated_wave_tokens: number;
+    cooldown_until: string | null;
+    confidence: LimitConfidence;
+    source: LimitSource;
+    resolved_limits: ResolvedLimits;
+    host_concurrency_limit: HostConcurrencyLimit | null;
+    model: string | null;
+    quota_source_snapshot?: import("./quotaSource.js").QuotaUsageSnapshot | null;
+    /**
+     * Which cap bound the final `max_concurrent` ("none" if nothing reduced the
+     * requested concurrency). Optional so existing constructions stay valid.
+     */
+    binding_cap?: WaveBindingCap;
+}
+export declare const BackoffStateSchema: z.ZodObject<{
+    consecutive_429_count: z.ZodNumber;
+    current_cooldown_ms: z.ZodNumber;
+    current_failure_weight: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    consecutive_429_count: number;
+    current_cooldown_ms: number;
+    current_failure_weight: number;
+}, {
+    consecutive_429_count: number;
+    current_cooldown_ms: number;
+    current_failure_weight: number;
+}>;
+export type BackoffState = z.infer<typeof BackoffStateSchema>;
+export interface ObservedWaveOutcome {
+    concurrency: number;
+    estimated_tokens: number;
+    /**
+     * - `success`: wave completed without error.
+     * - `rate_limited`: provider signalled 429 / quota exhaustion — applies cooldown + backoff.
+     * - `timeout`: execution deadline exceeded — records failure weight but no rate-limit cooldown.
+     * - `error`: provider returned a non-quota error (crash, network failure) — records failure
+     *   weight only; does NOT apply rate-limit cooldown (distinct from quota exhaustion).
+     */
+    outcome: "success" | "rate_limited" | "timeout" | "error";
+    cooldown_until?: string | null;
+    reset_at?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/quota/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/shared/quota/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB,gHAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,qBAAqB,sCAAoC,CAAC;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,gCAAgC,4EAK3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAM5B,CAAC;AACZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAQtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC3C,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC1C;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,2GAS/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,UAAU,EAAE,eAAe,CAAC;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,eAAe,EAAE,cAAc,CAAC;IAChC,sBAAsB,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,qBAAqB,CAAC,EAAE,OAAO,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC7E;;;OAGG;IACH,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAMpB,CAAC;AACZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,OAAO,EAAE,SAAS,GAAG,cAAc,GAAG,SAAS,GAAG,OAAO,CAAC;IAC1D,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B"}

package/dist/shared/quota/types.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export const LimitSourceSchema = z.enum([
+    "explicit_config",
+    "discovered_capability",
+    "cli_flags",
+    "provider_default",
+    "learned",
+    "default",
+]);
+export const LimitConfidenceSchema = z.enum(["high", "medium", "low"]);
+export const HostConcurrencyLimitSourceSchema = z.enum([
+    "cli_flags",
+    "host_reported",
+    "session_config",
+    "environment",
+]);
+export const HostConcurrencyLimitSchema = z
+    .object({
+    active_subagents: z.number().int().min(1),
+    source: HostConcurrencyLimitSourceSchema,
+    description: z.string().min(1),
+})
+    .strict();
+export const ResolvedLimitsSchema = z
+    .object({
+    context_tokens: z.number().int().min(1),
+    output_tokens: z.number().int().min(1),
+    requests_per_minute: z.number().int().min(1).nullable(),
+    input_tokens_per_minute: z.number().int().min(1).nullable(),
+    output_tokens_per_minute: z.number().int().min(1).nullable(),
+})
+    .strict();
+/**
+ * Identifies which cap actually bound the final wave size, so an operator can
+ * see *why* a wave was throttled (or that nothing throttled it) without
+ * re-deriving the decision. Set by `scheduleWave`; logged by callers that hold a
+ * RunLogger as a `kind:"scope"` event.
+ */
+export const WaveBindingCapSchema = z.enum([
+    "rpm",
+    "tpm",
+    "learned",
+    "fallback",
+    "first_contact",
+    "cooldown",
+    "host_concurrency",
+    "none",
+]);
+export const BackoffStateSchema = z
+    .object({
+    consecutive_429_count: z.number().int().min(0),
+    current_cooldown_ms: z.number().int().min(0),
+    current_failure_weight: z.number().min(0),
+})
+    .strict();
+//# sourceMappingURL=types.js.map

package/dist/shared/quota/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/shared/quota/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC;IACtC,iBAAiB;IACjB,uBAAuB;IACvB,WAAW;IACX,kBAAkB;IAClB,SAAS;IACT,SAAS;CACV,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;AAGvE,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,IAAI,CAAC;IACrD,WAAW;IACX,eAAe;IACf,gBAAgB;IAChB,aAAa;CACd,CAAC,CAAC;AAKH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzC,MAAM,EAAE,gCAAgC;IACxC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC/B,CAAC;KACD,MAAM,EAAE,CAAC;AAGZ,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACtC,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACvD,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC3D,wBAAwB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC7D,CAAC;KACD,MAAM,EAAE,CAAC;AAqBZ;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC;IACzC,KAAK;IACL,KAAK;IACL,SAAS;IACT,UAAU;IACV,eAAe;IACf,UAAU;IACV,kBAAkB;IAClB,MAAM;CACP,CAAC,CAAC;AAoBH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,MAAM,CAAC;IACN,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,sBAAsB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1C,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/shared/reReview/projectionDiff.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Diff-based re-review primitives (shared, B2/B3).
+ *
+ * Both orchestrators make staleness content/semantics-aware: a dependency is
+ * recorded and compared by the hash of its *semantic projection* (only the
+ * load-bearing structure a downstream consumes), and a verdict-bearing review
+ * that must re-run after a genuine upstream change is handed its prior verdict
+ * plus the precise changed-since-last-review delta — so it re-affirms cheaply or
+ * revises only the affected items, never a blind full re-run.
+ *
+ * Each orchestrator owns its own *projection table* (which fields of which
+ * artifact are load-bearing — remediate's `semanticProjection`, audit-code's
+ * `designReviewProjection`), but the GENERIC machinery is single-sourced here:
+ * the order-independent stable serialization, the leaf-level projection diff,
+ * and the re-review prompt section. This keeps the two halves of the pipeline in
+ * lockstep (one diff algorithm, one prompt shape) while leaving the
+ * domain-specific projection to each side.
+ */
+/**
+ * Order-independent stable serialization of a projection. Object keys are sorted
+ * so two payloads that differ only in key order project to the same string (and
+ * thus the same semantic hash); arrays preserve order (element order can be
+ * load-bearing). `undefined` is encoded as `null` so a present-but-undefined
+ * field and an absent field collapse — they carry the same meaning here.
+ */
+export declare function stableStringifyProjection(value: unknown): string;
+/**
+ * Render a leaf-level diff between two projections as `+`/`-`/`~` lines. Returns
+ * an empty array when the projections are identical. Bounded to MAX_DIFF_LINES
+ * with an explicit overflow note (never silently truncated).
+ */
+export declare function diffProjections(prior: unknown, current: unknown): string[];
+/** One changed upstream input: its label plus the field-level diff lines. */
+export interface ProjectionDiffEntry {
+    /** Human-readable name of the changed input (artifact / dependency name). */
+    label: string;
+    /** Leaf-level `+`/`-`/`~` diff lines from `diffProjections`. */
+    lines: string[];
+}
+export interface ReReviewSectionInput {
+    /**
+     * The verdict the prior review emitted — what a re-review re-affirms verbatim
+     * when the changes below do not affect it.
+     */
+    priorPayload: unknown;
+    /** Per-input diffs, empty when nothing changed. */
+    changedInputs: ProjectionDiffEntry[];
+    /** True when no upstream projection actually changed (re-affirm verbatim). */
+    allUnchanged: boolean;
+    /**
+     * The noun for the thing being re-reviewed, e.g. `"artifact"` or
+     * `"design-review pass"`. Used only in the section prose. Defaults to
+     * `"review"`.
+     */
+    subjectNoun?: string;
+}
+/**
+ * Render the diff-based re-review section appended to a review's re-emit prompt.
+ * Carries the prior verdict and the precise changed-since-last-review delta, and
+ * instructs the worker to re-affirm the prior verdict when the delta does not
+ * affect it, or revise only the affected items otherwise. Enforced by the tool
+ * (the re-emit prompt carries the delta), never left to the host to remember.
+ */
+export declare function renderDiffReReviewSection(input: ReReviewSectionInput): string;
+//# sourceMappingURL=projectionDiff.d.ts.map

package/dist/shared/reReview/projectionDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionDiff.d.ts","sourceRoot":"","sources":["../../../src/shared/reReview/projectionDiff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAYhE;AA2CD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAsB1E;AAID,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,mDAAmD;IACnD,aAAa,EAAE,mBAAmB,EAAE,CAAC;IACrC,8EAA8E;IAC9E,YAAY,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAmC7E"}

package/dist/shared/reReview/projectionDiff.js

@@ -0,0 +1,144 @@
+/**
+ * Diff-based re-review primitives (shared, B2/B3).
+ *
+ * Both orchestrators make staleness content/semantics-aware: a dependency is
+ * recorded and compared by the hash of its *semantic projection* (only the
+ * load-bearing structure a downstream consumes), and a verdict-bearing review
+ * that must re-run after a genuine upstream change is handed its prior verdict
+ * plus the precise changed-since-last-review delta — so it re-affirms cheaply or
+ * revises only the affected items, never a blind full re-run.
+ *
+ * Each orchestrator owns its own *projection table* (which fields of which
+ * artifact are load-bearing — remediate's `semanticProjection`, audit-code's
+ * `designReviewProjection`), but the GENERIC machinery is single-sourced here:
+ * the order-independent stable serialization, the leaf-level projection diff,
+ * and the re-review prompt section. This keeps the two halves of the pipeline in
+ * lockstep (one diff algorithm, one prompt shape) while leaving the
+ * domain-specific projection to each side.
+ */
+/**
+ * Order-independent stable serialization of a projection. Object keys are sorted
+ * so two payloads that differ only in key order project to the same string (and
+ * thus the same semantic hash); arrays preserve order (element order can be
+ * load-bearing). `undefined` is encoded as `null` so a present-but-undefined
+ * field and an absent field collapse — they carry the same meaning here.
+ */
+export function stableStringifyProjection(value) {
+    if (value === undefined || value === null)
+        return "null";
+    if (typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringifyProjection(item)).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringifyProjection(item)}`)
+        .join(",")}}`;
+}
+// ── Projection diffing ─────────────────────────────────────────────────────────
+/** Flatten a projection to leaf path → stable string value. */
+function flatten(value, prefix, out) {
+    if (value === null || value === undefined) {
+        out.set(prefix || "(root)", "null");
+        return;
+    }
+    if (typeof value !== "object") {
+        out.set(prefix || "(root)", JSON.stringify(value));
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            out.set(prefix || "(root)", "[]");
+            return;
+        }
+        value.forEach((item, i) => flatten(item, `${prefix}[${i}]`, out));
+        return;
+    }
+    const keys = Object.keys(value).sort();
+    if (keys.length === 0) {
+        out.set(prefix || "(root)", "{}");
+        return;
+    }
+    for (const key of keys) {
+        flatten(value[key], prefix ? `${prefix}.${key}` : key, out);
+    }
+}
+const MAX_DIFF_LINES = 40;
+/** A truncated value for display (long strings get an ellipsis). */
+function short(value) {
+    return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+}
+/**
+ * Render a leaf-level diff between two projections as `+`/`-`/`~` lines. Returns
+ * an empty array when the projections are identical. Bounded to MAX_DIFF_LINES
+ * with an explicit overflow note (never silently truncated).
+ */
+export function diffProjections(prior, current) {
+    const a = new Map();
+    const b = new Map();
+    flatten(prior, "", a);
+    flatten(current, "", b);
+    const allKeys = [...new Set([...a.keys(), ...b.keys()])].sort();
+    const lines = [];
+    for (const key of allKeys) {
+        const before = a.get(key);
+        const after = b.get(key);
+        if (before === after)
+            continue;
+        if (before === undefined)
+            lines.push(`+ ${key}: ${short(after)}`);
+        else if (after === undefined)
+            lines.push(`- ${key}: ${short(before)}`);
+        else
+            lines.push(`~ ${key}: ${short(before)} → ${short(after)}`);
+    }
+    if (lines.length > MAX_DIFF_LINES) {
+        const shown = lines.slice(0, MAX_DIFF_LINES);
+        shown.push(`… and ${lines.length - MAX_DIFF_LINES} more changed field(s).`);
+        return shown;
+    }
+    return lines;
+}
+/**
+ * Render the diff-based re-review section appended to a review's re-emit prompt.
+ * Carries the prior verdict and the precise changed-since-last-review delta, and
+ * instructs the worker to re-affirm the prior verdict when the delta does not
+ * affect it, or revise only the affected items otherwise. Enforced by the tool
+ * (the re-emit prompt carries the delta), never left to the host to remember.
+ */
+export function renderDiffReReviewSection(input) {
+    const subjectNoun = input.subjectNoun ?? "review";
+    const priorJson = JSON.stringify(input.priorPayload, null, 2);
+    const deltaBlock = input.allUnchanged
+        ? "_No upstream semantic change was detected._ The inputs you reviewed are unchanged in substance; re-emit your prior verdict verbatim (only the provenance/timestamp differs)."
+        : input.changedInputs
+            .map((entry) => `### Changed: \`${entry.label}\`\n\n\`\`\`diff\n${entry.lines.join("\n")}\n\`\`\``)
+            .join("\n\n");
+    return `## Diff-Based Re-Review — only re-examine what changed
+
+This ${subjectNoun} was already reviewed; its upstreams then changed, so it must be
+re-emitted. **Do NOT re-run the full review.** Diff against your prior verdict
+and re-examine ONLY the changes below.
+
+### Your prior verdict (re-affirm it verbatim if the changes below do not affect it)
+
+\`\`\`json
+${priorJson}
+\`\`\`
+
+### Changed since your prior verdict
+
+${deltaBlock}
+
+### How to respond
+
+- If the changes above do **not** affect any item in your prior verdict, re-emit
+  the prior verdict unchanged (you may freshen ids/timestamps the schema requires).
+- If they **do**, revise ONLY the affected items and leave the rest as they were.
+- Do not invent new findings unrelated to the changes above.
+`;
+}
+//# sourceMappingURL=projectionDiff.js.map

package/dist/shared/reReview/projectionDiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionDiff.js","sourceRoot":"","sources":["../../../src/shared/reReview/projectionDiff.ts"],"names":[],"mappings":"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"}

package/dist/shared/rolling/pausedState.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Rolling engine paused-state management (N-S09).
+ *
+ * Owns the `waiting_for_provider` resumable paused state that the rolling
+ * engine enters when the confirmed provider pool empties mid-run.
+ *
+ * Invariants enforced here:
+ *   INV-S03 — settled Gate-0/Gate-1 exclusions are never re-offered on
+ *              re-discovery. `filterNewProviders` strips them from every
+ *              re-discovery pass; `SettledExclusionSet` is never mutated.
+ *   CE-003/CE-205 — no indefinite stall. After `LIVELOCK_PAUSE_LIMIT`
+ *              consecutive pauses with zero net new capacity the engine
+ *              transitions to `terminal/livelock` and yields the stranded
+ *              subtree to the consumer-provided terminal handler (N-CE301).
+ *
+ * This module is purely logic — zero runtime dependencies beyond Node
+ * built-ins. The consumer wires the terminal action after receiving
+ * `{ kind: 'terminal', reason: 'livelock' }`.
+ */
+/**
+ * Top-level lifecycle state of the rolling dispatch engine.
+ *
+ * - `running`              — confirmed pool has capacity; dispatch proceeding.
+ * - `waiting_for_provider` — confirmed pool emptied mid-run; engine is
+ *                            explicitly paused and resumable.
+ * - `terminal`             — engine is done (complete, livelock, or handed
+ *                            off to the consumer terminal handler).
+ */
+export type RollingEngineLifecycleState = {
+    kind: "running";
+} | {
+    kind: "waiting_for_provider";
+    /** ISO timestamp when the engine entered the paused state. */
+    paused_at: string;
+    /** Number of consecutive pauses with no net new provider capacity. */
+    pause_count: number;
+    /** Node IDs that are stranded waiting for a provider. */
+    stranded_node_ids: string[];
+} | {
+    kind: "terminal";
+    reason: "livelock" | "consumer_terminal" | "complete";
+    stranded_node_ids: string[];
+};
+/**
+ * Opaque set of provider identifiers that a Gate-0/Gate-1 user has
+ * explicitly excluded. Carried across re-discovery rounds; never cleared.
+ *
+ * Use a `ReadonlySet<string>` so callers cannot accidentally mutate it.
+ */
+export type SettledExclusionSet = ReadonlySet<string>;
+/**
+ * Default number of consecutive `waiting_for_provider` pauses (with zero net
+ * new capacity) after which the engine transitions to `terminal/livelock`.
+ */
+export declare const LIVELOCK_PAUSE_LIMIT = 3;
+/**
+ * Pure function: return only providers not present in `settled`.
+ *
+ * Guarantees that re-discovery never re-offers a Gate-0/Gate-1 settled
+ * exclusion (INV-S03). The `settled` set is never mutated.
+ *
+ * @param discovered  Provider identifiers returned by the latest re-discovery pass.
+ * @param settled     The accumulated exclusion set; immutable.
+ * @returns           Only those identifiers not already in `settled`.
+ */
+export declare function filterNewProviders(discovered: string[], settled: SettledExclusionSet): string[];
+/**
+ * Pure predicate: returns `true` when the no-progress livelock condition is met.
+ *
+ * Livelock is triggered when:
+ *   - `pauseCount >= limit` (at or beyond the configured threshold), AND
+ *   - `netNewCapacity === 0`  (no genuinely-new providers arrived this round).
+ *
+ * @param pauseCount      Number of consecutive pauses recorded so far (inclusive of the current one).
+ * @param netNewCapacity  Count of genuinely-new providers surfaced this round.
+ * @param limit           Pause threshold; defaults to `LIVELOCK_PAUSE_LIMIT`.
+ */
+export declare function checkLivelockGuard(pauseCount: number, netNewCapacity: number, limit?: number): boolean;
+/**
+ * Options for `advancePausedState`.
+ */
+export interface AdvancePausedStateOptions {
+    /** The current `waiting_for_provider` state. */
+    current: Extract<RollingEngineLifecycleState, {
+        kind: "waiting_for_provider";
+    }>;
+    /** Provider identifiers returned by the latest re-discovery probe. */
+    rediscoveredProviders: string[];
+    /** The accumulated settled-exclusion set (not mutated). */
+    settledExclusions: SettledExclusionSet;
+    /** Override for the livelock limit; defaults to `LIVELOCK_PAUSE_LIMIT`. */
+    livelockLimit?: number;
+}
+/**
+ * Single transition function for the `waiting_for_provider` paused state.
+ *
+ * Decision tree:
+ *   1. Call `filterNewProviders` to surface only genuinely-new providers
+ *      (strips settled exclusions — INV-S03).
+ *   2. If `genuinelyNew.length > 0` → return `{ kind: 'running' }`.
+ *   3. Else increment `pause_count` and call `checkLivelockGuard`.
+ *      a. Livelock triggered → return `{ kind: 'terminal', reason: 'livelock', ... }`.
+ *      b. Below limit → return updated `waiting_for_provider` with bumped
+ *         `pause_count`; `paused_at` and `stranded_node_ids` are preserved.
+ *
+ * This function never mutates its inputs.
+ */
+export declare function advancePausedState(opts: AdvancePausedStateOptions): RollingEngineLifecycleState;
+//# sourceMappingURL=pausedState.d.ts.map

package/dist/shared/rolling/pausedState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pausedState.d.ts","sourceRoot":"","sources":["../../../src/shared/rolling/pausedState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH;;;;;;;;GAQG;AACH,MAAM,MAAM,2BAA2B,GACnC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IACE,IAAI,EAAE,sBAAsB,CAAC;IAC7B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,UAAU,GAAG,mBAAmB,GAAG,UAAU,CAAC;IACtD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAMtD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAMtC;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,EAAE,mBAAmB,GAC3B,MAAM,EAAE,CAEV;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,MAA6B,GACnC,OAAO,CAET;AAMD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC,2BAA2B,EAAE;QAAE,IAAI,EAAE,sBAAsB,CAAA;KAAE,CAAC,CAAC;IAChF,sEAAsE;IACtE,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,2DAA2D;IAC3D,iBAAiB,EAAE,mBAAmB,CAAC;IACvC,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,yBAAyB,GAC9B,2BAA2B,CA6B7B"}

package/dist/shared/rolling/pausedState.js

@@ -0,0 +1,100 @@
+/**
+ * Rolling engine paused-state management (N-S09).
+ *
+ * Owns the `waiting_for_provider` resumable paused state that the rolling
+ * engine enters when the confirmed provider pool empties mid-run.
+ *
+ * Invariants enforced here:
+ *   INV-S03 — settled Gate-0/Gate-1 exclusions are never re-offered on
+ *              re-discovery. `filterNewProviders` strips them from every
+ *              re-discovery pass; `SettledExclusionSet` is never mutated.
+ *   CE-003/CE-205 — no indefinite stall. After `LIVELOCK_PAUSE_LIMIT`
+ *              consecutive pauses with zero net new capacity the engine
+ *              transitions to `terminal/livelock` and yields the stranded
+ *              subtree to the consumer-provided terminal handler (N-CE301).
+ *
+ * This module is purely logic — zero runtime dependencies beyond Node
+ * built-ins. The consumer wires the terminal action after receiving
+ * `{ kind: 'terminal', reason: 'livelock' }`.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * Default number of consecutive `waiting_for_provider` pauses (with zero net
+ * new capacity) after which the engine transitions to `terminal/livelock`.
+ */
+export const LIVELOCK_PAUSE_LIMIT = 3;
+// ---------------------------------------------------------------------------
+// filterNewProviders
+// ---------------------------------------------------------------------------
+/**
+ * Pure function: return only providers not present in `settled`.
+ *
+ * Guarantees that re-discovery never re-offers a Gate-0/Gate-1 settled
+ * exclusion (INV-S03). The `settled` set is never mutated.
+ *
+ * @param discovered  Provider identifiers returned by the latest re-discovery pass.
+ * @param settled     The accumulated exclusion set; immutable.
+ * @returns           Only those identifiers not already in `settled`.
+ */
+export function filterNewProviders(discovered, settled) {
+    return discovered.filter((id) => !settled.has(id));
+}
+// ---------------------------------------------------------------------------
+// checkLivelockGuard
+// ---------------------------------------------------------------------------
+/**
+ * Pure predicate: returns `true` when the no-progress livelock condition is met.
+ *
+ * Livelock is triggered when:
+ *   - `pauseCount >= limit` (at or beyond the configured threshold), AND
+ *   - `netNewCapacity === 0`  (no genuinely-new providers arrived this round).
+ *
+ * @param pauseCount      Number of consecutive pauses recorded so far (inclusive of the current one).
+ * @param netNewCapacity  Count of genuinely-new providers surfaced this round.
+ * @param limit           Pause threshold; defaults to `LIVELOCK_PAUSE_LIMIT`.
+ */
+export function checkLivelockGuard(pauseCount, netNewCapacity, limit = LIVELOCK_PAUSE_LIMIT) {
+    return pauseCount >= limit && netNewCapacity === 0;
+}
+/**
+ * Single transition function for the `waiting_for_provider` paused state.
+ *
+ * Decision tree:
+ *   1. Call `filterNewProviders` to surface only genuinely-new providers
+ *      (strips settled exclusions — INV-S03).
+ *   2. If `genuinelyNew.length > 0` → return `{ kind: 'running' }`.
+ *   3. Else increment `pause_count` and call `checkLivelockGuard`.
+ *      a. Livelock triggered → return `{ kind: 'terminal', reason: 'livelock', ... }`.
+ *      b. Below limit → return updated `waiting_for_provider` with bumped
+ *         `pause_count`; `paused_at` and `stranded_node_ids` are preserved.
+ *
+ * This function never mutates its inputs.
+ */
+export function advancePausedState(opts) {
+    const { current, rediscoveredProviders, settledExclusions, livelockLimit } = opts;
+    const genuinelyNew = filterNewProviders(rediscoveredProviders, settledExclusions);
+    // New capacity arrived — transition back to running.
+    if (genuinelyNew.length > 0) {
+        return { kind: "running" };
+    }
+    // No new capacity — increment pause count and check for livelock.
+    const nextPauseCount = current.pause_count + 1;
+    const livelock = checkLivelockGuard(nextPauseCount, 0, livelockLimit);
+    if (livelock) {
+        return {
+            kind: "terminal",
+            reason: "livelock",
+            stranded_node_ids: current.stranded_node_ids,
+        };
+    }
+    // Still waiting — bump pause count, preserve everything else.
+    return {
+        kind: "waiting_for_provider",
+        paused_at: current.paused_at,
+        pause_count: nextPauseCount,
+        stranded_node_ids: current.stranded_node_ids,
+    };
+}
+//# sourceMappingURL=pausedState.js.map

package/dist/shared/rolling/pausedState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pausedState.js","sourceRoot":"","sources":["../../../src/shared/rolling/pausedState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAwCH,8EAA8E;AAC9E,YAAY;AACZ,8EAA8E;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC,8EAA8E;AAC9E,qBAAqB;AACrB,8EAA8E;AAE9E;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAoB,EACpB,OAA4B;IAE5B,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;AACrD,CAAC;AAED,8EAA8E;AAC9E,qBAAqB;AACrB,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAkB,EAClB,cAAsB,EACtB,QAAgB,oBAAoB;IAEpC,OAAO,UAAU,IAAI,KAAK,IAAI,cAAc,KAAK,CAAC,CAAC;AACrD,CAAC;AAoBD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAA+B;IAE/B,MAAM,EAAE,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;IAElF,MAAM,YAAY,GAAG,kBAAkB,CAAC,qBAAqB,EAAE,iBAAiB,CAAC,CAAC;IAElF,qDAAqD;IACrD,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAC7B,CAAC;IAED,kEAAkE;IAClE,MAAM,cAAc,GAAG,OAAO,CAAC,WAAW,GAAG,CAAC,CAAC;IAC/C,MAAM,QAAQ,GAAG,kBAAkB,CAAC,cAAc,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;IAEtE,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,UAAU;YAClB,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;SAC7C,CAAC;IACJ,CAAC;IAED,8DAA8D;IAC9D,OAAO;QACL,IAAI,EAAE,sBAAsB;QAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,WAAW,EAAE,cAAc;QAC3B,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;KAC7C,CAAC;AACJ,CAAC"}

package/dist/shared/tokens.d.ts

@@ -0,0 +1,24 @@
+export declare const DEFAULT_CONTEXT_TOKENS = 32000;
+export declare const DEFAULT_OUTPUT_TOKENS = 4096;
+export declare const BLOCK_SAFETY_MARGIN = 0.7;
+export declare const BYTES_PER_TOKEN = 4;
+export declare const ESTIMATED_TOKENS_PER_LINE = 4;
+export declare const ESTIMATED_PROMPT_OVERHEAD_TOKENS = 900;
+export declare const ESTIMATED_ITEM_OVERHEAD_TOKENS = 600;
+/**
+ * Estimate tokens from a raw byte count. Non-finite or non-positive inputs
+ * estimate to zero so missing `size_bytes` never inflates a budget.
+ */
+export declare function estimateTokensFromBytes(bytes: number): number;
+/**
+ * Usable context budget for a single work block: (context − reserved output)
+ * scaled by the safety margin. Callers pass the discovered/configured window;
+ * absent that, sizing falls to the conservative floor (never a guessed
+ * per-model window).
+ */
+export declare function resolveContextBudget(input: {
+    contextTokens?: number | null;
+    reservedOutputTokens?: number | null;
+    safetyMargin?: number;
+}): number;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/shared/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/shared/tokens.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAI3C,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAIvC,eAAO,MAAM,eAAe,IAAI,CAAC;AAIjC,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAK3C,eAAO,MAAM,gCAAgC,MAAM,CAAC;AACpD,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAKT"}