@quantiya/codevibe-core 2.0.0 → 2.0.2

package/dist/local-executor/types.d.ts

@@ -0,0 +1,417 @@
+import type { ChildProcess } from 'node:child_process';
+import type { SubstrateHandle, SubstrateProc } from '../substrate/types';
+import type { AuthorityRefusal, AuthorityScope } from './authority';
+export type ProcessRole = 'implementor' | 'reviewer' | 'health_probe' | 'auth_probe' | 'model_probe';
+export type AgentKind = 'CLAUDE' | 'GEMINI' | 'CODEX' | 'ANTIGRAVITY';
+export type FailureClass = null | 'quota_exhausted' | 'auth_failed' | 'timeout' | 'unavailable' | 'user_aborted';
+export interface SpawnArgs {
+    argv: string[];
+    workingDir: string;
+    role: ProcessRole;
+    agentKind?: AgentKind;
+    timeoutMs: number | null;
+    envOverrides?: Record<string, string>;
+    stdinTty?: boolean;
+    stdinPayload?: string;
+    signal?: AbortSignal;
+    taskId?: string;
+    onProcessSpawned?: ProcessSpawnedHook;
+    onProcessExited?: ProcessExitedHook;
+    substrate?: SubstrateHandle;
+    requireConfined?: boolean;
+}
+export interface ProcessSpawnedInfo {
+    pid: number;
+    role: ProcessRole;
+    agentKind: AgentKind | undefined;
+    spawnedAt: string;
+}
+export interface ProcessExitedInfo {
+    pid: number;
+    exitCode: number;
+    failureClass: FailureClass;
+    exitedAt: string;
+    runtimeMs: number;
+}
+export type ProcessSpawnedHook = (info: ProcessSpawnedInfo) => void;
+export type ProcessExitedHook = (info: ProcessExitedInfo) => void;
+export interface SpawnHandleBase {
+    pid: number;
+    role: ProcessRole;
+    agentKind: AgentKind | undefined;
+    spawnedAt: string;
+    /** Resolves when the child exits, regardless of cause. */
+    done: Promise<ProcessExitedInfo>;
+    /** Forcibly terminate (SIGKILL + cleanup). Idempotent. */
+    abort(): Promise<void>;
+    /** Captured stdout/stderr — local-only, never crosses the wire. */
+    stdout(): string;
+    stderr(): string;
+}
+export interface ImplementorHandle extends SpawnHandleBase {
+    kind: 'implementor';
+}
+export interface ReviewerHandle extends SpawnHandleBase {
+    kind: 'reviewer';
+}
+export interface ProbeHandle extends SpawnHandleBase {
+    kind: 'probe';
+}
+export declare class SpawnArgsInvalid extends Error {
+    readonly reason: string;
+    readonly offendingKey?: string | undefined;
+    constructor(reason: string, offendingKey?: string | undefined);
+}
+export declare class SpawnConfinementUnavailable extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare const MARKER_ENV_KEYS: {
+    readonly CHILD: "CODEVIBE_CHILD_PROCESS";
+    readonly ROLE: "CODEVIBE_PROCESS_ROLE";
+    readonly QUORUM: "QUORUM_REVIEWER_SUBPROCESS";
+};
+export declare const MARKER_KEY_SET: ReadonlySet<string>;
+export type AuthorityAction = {
+    kind: 'Write';
+    path: string;
+} | {
+    kind: 'Read';
+    path: string;
+} | {
+    kind: 'Network';
+    urlOrHost: string;
+} | {
+    kind: 'Command';
+    command: string;
+    argv: string[];
+};
+export interface GateDispatchPayload {
+    /** The DETERMINISTIC gate_id of this gate-run (the round-0 proposal gate id at START). */
+    gateRunId: string;
+    /** `"verification" | "reviewer_quorum" | "final_approval"` (snake_case wire form). */
+    gateType: string;
+    /** Present ONLY for `verification` gates (CP-3 — out of scope for CP-1.f single-task). */
+    verificationChecks?: string[];
+    /**
+     * Present ONLY once the per-seat reviewer panel is resolved. ABSENT at START
+     * (the proposal hasn't arrived) — `start_ports.rs:296` sets `reviewer_seats:
+     * None`. Each row is the camelCase `ReviewerSeatRow`
+     * (`{seatId, agentKind, role, reviewerPacketRef}`).
+     */
+    reviewerSeats?: GateDispatchReviewerSeat[];
+    /** Present ONLY for `final_approval` gates. */
+    finalApprovalSurface?: string;
+}
+/** One reviewer-seat row inside `GateDispatchPayload.reviewerSeats` (camelCase). */
+export interface GateDispatchReviewerSeat {
+    seatId: number;
+    /** UPPERCASE agent kind: `"CLAUDE" | "CODEX" | "GEMINI"`. */
+    agentKind: string;
+    /** UPPERCASE lens: `"ARCHITECTURE" | "CORRECTNESS" | ...`. */
+    role: string;
+    reviewerPacketRef: string;
+}
+export interface SignedEnvelope {
+    algorithm: 'ed25519' | 'p384-ecdsa';
+    publicKeyId: string;
+    signatureB64: string;
+    issuedAt: string;
+    nonceUlid: string;
+}
+/**
+ * Cross-track-conflict dispute context (§2.2, #C12-19). Present ONLY on a
+ * dispute re-dispatch; ABSENT (undefined) on a fresh `TrackAssigned`. The
+ * re-dispatched implementor/reviewers use it to know what to reconcile.
+ */
+export interface TrackConflictContext {
+    conflict_id: string;
+    shared_contract_ref: string;
+    peer_track_findings: unknown;
+}
+/**
+ * §2.2 `TrackAssigned` payload — launch track N. The LE spawns the implementor
+ * for this track in `state_dir`, idempotent by
+ * `(task_group_id, track_index, dispatch_generation)` (#C12-14/#C12-17).
+ */
+export interface TrackAssignedPayload {
+    task_group_id: string;
+    track_index: number;
+    task_id: string;
+    /** UPPERCASE adapter discriminator (CLAUDE | GEMINI | CODEX). */
+    implementor_agent: AgentKind;
+    /** snake_case OwnershipScope (advanced to the per-track authority scope). */
+    ownership_scope: {
+        write_paths: string[];
+        shared_contracts: {
+            path: string;
+            access: 'write' | 'read';
+        }[];
+        test_surfaces: string[];
+        auto_modified_files: string[];
+    };
+    is_shared_test_owner: boolean;
+    /** `<repo>/.codevibe/state/<task_group_id>/<track_index>/`. */
+    state_dir: string;
+    dispatch_id: string;
+    dispatch_generation: number;
+    /** Option — present on a dispute re-dispatch (#C12-19), absent on fresh. */
+    conflict_context?: TrackConflictContext;
+}
+/**
+ * §2.2 `MergeGateDispatch` payload — run the shared integration verification.
+ * The `owner_track_index` track runs the integration check named by
+ * `integration_check_spec` (§12 Q1 — CP-3 verification-gate kinds, NOT a
+ * free-form shell), classifies + signs the result (#C12-8), and reports
+ * `submitMergeGateVerdict`.
+ */
+export interface MergeGateDispatchPayload {
+    task_group_id: string;
+    merge_gate_id: string;
+    /**
+     * §12 Q1 — names CP-3 verification-runner wrapper(s). On the wire this is the
+     * `VerificationGateKind` list the owner track named at `createTaskGroup`. A
+     * single string is accepted for forward-compat and coerced to a 1-element
+     * list by the runner.
+     */
+    integration_check_spec: string | string[];
+    owner_track_index: number;
+    dispatch_id: string;
+    dispatch_generation: number;
+}
+/**
+ * §2.2 `TaskGroupHalted` payload — group halted/escalated (expanded escalation
+ * fields per the Stage-2 §11.3 fix). The LE surfaces the choices to the UI
+ * (NOTIFICATION) + signals the in-flight track processes to stop. The deep
+ * auto-resolution decision tree is server-side (#C12-3) — the LE only consumes,
+ * surfaces, and stops. [DEFERRED — GA/CP-12 Wave 3+] for choice-driven
+ * auto-actions.
+ */
+export interface TaskGroupHaltedPayload {
+    task_group_id: string;
+    halt_reason: string;
+    per_track_status: {
+        track_index: number;
+        state: string;
+        agent?: string;
+    }[];
+    gates_passed_failed?: unknown;
+    /**
+     * #584 r2 — internally-tagged union pinned to core-rs `HaltFixOwner`
+     * (`class_b_envelope.rs`, `rename_all = "snake_case"` tags +
+     * `rename_all_fields = "camelCase"`): wire `{kind: "track", trackIndex}` |
+     * `{kind: "serial_owner"}`. `normalizeTaskGroupHaltedWire` maps the field to
+     * the internal snake_case `track_index`.
+     */
+    recommended_fix_owner?: {
+        kind: string;
+        track_index?: number;
+    };
+    remaining_budget?: {
+        auto_revise_used?: number;
+        auto_revise_cap?: number;
+        wallclock_elapsed_ms?: number;
+        wallclock_cap_ms?: number;
+    };
+    /**
+     * #584 r2 — pinned to core-rs `HaltChoice` (same serde shape as
+     * `HaltFixOwner`): wire `{kind: "retry_serial_owner" | "retry_track" |
+     * "continue_manually" | "accept_partial" | "abort", trackIndex?}` — NOT a
+     * string list (the pre-#584 annotation was a wrong pin). Display-only.
+     */
+    choices: {
+        kind: string;
+        track_index?: number;
+    }[];
+}
+import type { AgentKind as ReviewerAgentKind, ReviewerRole } from '../reviewer/types';
+/**
+ * CP-1.f §3.C.21 — `REVIEWER_DISPATCH` Class B payload (engine → desktop).
+ * Tells the desktop to spawn one reviewer subprocess for the named seat; the
+ * rendered prompt is FETCHED out-of-band via `getReviewerPrompt` (the dispatch
+ * carries no inline prompt). Pinned to `class_b_envelope.rs::ReviewerDispatchPayload`.
+ */
+export interface ReviewerDispatchPayload {
+    /** Gate this dispatch belongs to (UUID string). */
+    gateId: string;
+    /**
+     * RESOLVED seat-id STRING (post-promotion), e.g. `"1::codex"` or bare `"1"`.
+     * The numeric seat for `getReviewerPrompt` is the substring before `"::"`.
+     */
+    seatId: string;
+    /** Lowercase agent kind (`"claude" | "gemini" | "codex"`) — chosen from the resolved plan. */
+    agentKind: ReviewerAgentKind;
+    /** snake_case reviewer lens for the seat (e.g. `"correctness"`). */
+    role: ReviewerRole;
+    /** Deterministic dispatch ULID (LOCK #C3F-6). */
+    dispatchUlid: string;
+    /** Attempt number (0-indexed) used as the ULID seed. */
+    attemptNumber: number;
+    /** Producer process-id (no-same-process self-review check, LOCK #C3F-7). */
+    producerProcessId: string;
+    /** Producer session-id (paired with `producerProcessId`). */
+    producerSessionId: string;
+}
+/** One reviewer's REVISE finding inside `ReviseFeedbackPayload.seatFindings`. */
+export interface ReviseSeatFinding {
+    /** Resolved seat-id string (post-promotion if applicable). */
+    seatId: string;
+    /** snake_case reviewer lens. */
+    role: ReviewerRole;
+    /** Free-form findings narrative. */
+    findings: string;
+}
+/**
+ * CP-1.f §3.C.23 — `REVISE_FEEDBACK` Class B payload (engine → desktop). The
+ * desktop re-runs the implementor for round N+1 with the aggregated findings,
+ * then `submitImplementorOutput(nextGateId, nextRound)`. Pinned to
+ * `class_b_envelope.rs::ReviseFeedbackPayload`.
+ */
+export interface ReviseFeedbackPayload {
+    /** The OLD (parent) gate id that produced the REVISE. */
+    gateId: string;
+    /** Per-seat REVISE findings (ordered by ascending seat_id). */
+    seatFindings: ReviseSeatFinding[];
+    /** Round number (0-indexed) the REVISE landed at. */
+    roundNumber: number;
+    /** The DETERMINISTIC round-N+1 gate id the desktop targets with `submitImplementorOutput`. */
+    nextGateId: string;
+    /** The round number of the next round (`roundNumber + 1`). */
+    nextRound: number;
+    /** DETERMINISTIC dedup key keyed `(parentGateId, nextGateId, nextRound)` — the double-spawn guard. */
+    reviseFeedbackId: string;
+}
+export type ClassBInbound = {
+    kind: 'PlannerDecisionApproved';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'GateDispatch';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'ContinuationOffer';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'TaskAuthorized';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'PolicyRejection';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'TrackAssigned';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'MergeGateDispatch';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'TaskGroupHalted';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'ReviewerDispatch';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+} | {
+    kind: 'ReviseFeedback';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
+};
+export type ExecutorError = {
+    kind: 'AuthorityRefusal';
+    refusal: AuthorityRefusal;
+} | {
+    kind: 'SpawnFailed';
+    detail: string;
+} | {
+    kind: 'SubprocessIo';
+    detail: string;
+} | {
+    kind: 'SignatureVerification';
+    detail: string;
+} | {
+    kind: 'MalformedClassB';
+    detail: string;
+} | {
+    kind: 'PolicyMismatch';
+    detail: string;
+};
+export type FileChangeKind = 'Created' | 'Modified' | 'Deleted';
+export type HookEvent = {
+    kind: 'ToolUse';
+    sessionId: string;
+    toolName: string;
+    toolInput: unknown;
+    timestamp: string;
+} | {
+    kind: 'FileChange';
+    sessionId: string;
+    path: string;
+    change: FileChangeKind;
+    timestamp: string;
+} | {
+    kind: 'ProcessExited';
+    sessionId: string;
+    pid: number;
+    exitCode: number;
+    timestamp: string;
+    failureClass?: FailureClass | undefined;
+    failureSignal?: NodeJS.Signals | undefined;
+} | {
+    kind: 'UserPrompt';
+    sessionId: string;
+    contentB64: string;
+    timestamp: string;
+} | {
+    kind: 'AssistantText';
+    sessionId: string;
+    contentB64: string;
+    timestamp: string;
+};
+export interface LocalExecutor {
+    spawnImplementor(args: SpawnArgs): Promise<ImplementorHandle>;
+    spawnReviewer(args: SpawnArgs): Promise<ReviewerHandle>;
+    spawnHealthProbe(args: SpawnArgs): Promise<ProbeHandle>;
+    /**
+     * Single-entrypoint authority gate. Dispatches to `enforceWrite` /
+     * `enforceRead` / `enforceNetwork` / `enforceCommand` based on `action.kind`.
+     * Throws `AuthorityError` on refusal (master §9:1284).
+     */
+    enforceAuthority(action: AuthorityAction): Promise<void>;
+    ingestHookEvent(event: HookEvent): Promise<void>;
+    /** Read-only view of the current TASK_AUTHORIZED.authorityScope. */
+    authorityScope(): Readonly<AuthorityScope>;
+    /**
+     * CP-1.c STUB; CP-1.e wires real AppSync subscription + signature verification.
+     * `envelopeTaskId` (Audited-path fix B) — the outer Class B envelope's taskId,
+     * forwarded so a PolicyRejection (payload carries no taskId) discards exactly
+     * the rejected task's shadow. Optional for non-WS callers / tests.
+     */
+    consumeClassB(packet: ClassBInbound, envelopeTaskId?: string): Promise<void>;
+    /**
+     * CP-12 W4 (#593) — team-dispatch recovery. Re-launch a track whose round-0
+     * `TrackAssigned` was dropped by the emit-before-subscribe race (the engine
+     * emits the per-track dispatch ~0.5s before the desktop's Class B subscription
+     * is established → live AppSync does not replay it). Exposes the private
+     * `launchTrack` body (register + brief bridge) and returns the explicit result
+     * the QuorumLoop `recoverTeamTracks` discriminates (`duplicate` returned BEFORE
+     * the bridge → recovery repairs the brief; `rejected` did not launch → skip).
+     * The single-track LE / non-team path never calls this (recovery is gated on a
+     * team session). Optional on the interface for non-team `LocalExecutor`
+     * implementations / tests.
+     */
+    recoverLaunchTrack?(payload: TrackAssignedPayload): Promise<'registered' | 'duplicate' | 'rejected'>;
+}
+export interface SpawnedProcess {
+    child: ChildProcess | SubstrateProc;
+    pid: number;
+    role: ProcessRole;
+    agentKind: AgentKind | undefined;
+    spawnedAt: string;
+    spawnedAtMs: number;
+}

package/dist/local-executor/verification-gates/build.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface BuildGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runBuildGate(args: BuildGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/deploy-preflight.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface DeployPreflightGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runDeployPreflightGate(args: DeployPreflightGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/diff-sanity.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface DiffSanityGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runDiffSanityGate(args: DiffSanityGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/hostile-grep.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface HostileGrepGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runHostileGrepGate(args: HostileGrepGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/lint.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface LintGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runLintGate(args: LintGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/shell-runner.d.ts

@@ -0,0 +1,40 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import type { GateRunResult } from '../verification-runner';
+export declare const VERIFICATION_RUNNER_ROLE = "verification_runner";
+export interface ShellRunArgs {
+    /** Command to execute (e.g. "cargo", "npm", "git"). */
+    command: string;
+    /** Arguments to pass to the command. */
+    args: string[];
+    /** Working directory — caller (gate wrapper) MUST pass the repo root. */
+    cwd: string;
+    /** Per-gate timeout budget in milliseconds. Required (LOCK #C3E-4). */
+    timeoutMs: number;
+    /** Optional extra env overrides on top of the marker injection. */
+    extraEnv?: Record<string, string>;
+    /** Optional clock seam for tests. Defaults to Date.now. */
+    nowMs?: () => number;
+    /**
+     * Test seam — injects a fake spawner. Production callers leave this
+     * undefined and the real `child_process.spawn` is used. The seam returns
+     * a minimal interface (write events, exit event) so test fixtures
+     * don't have to model the full Node ChildProcess surface.
+     */
+    spawnFn?: typeof nodeSpawn;
+}
+/**
+ * Run a single command-line under the verification-runner marker. Returns
+ * a `GateRunResult` matching what verification-runner.ts consumes.
+ *
+ * Captures FULL stdout/stderr (the runner truncates per LOCK #C3E-1) and
+ * fires the timeout race per LOCK #C3E-4. On timeout, the subprocess is
+ * killed (SIGKILL) and `timedOut: true` is set so the runner can apply
+ * the wire-form `exit_code = 124` regardless of what the platform
+ * returned for the killed process.
+ *
+ * NOTE: this primitive does NOT participate in authority enforcement.
+ * The orchestration shell establishes the authority scope BEFORE the
+ * verification runner is invoked, and the gates themselves operate on
+ * the user's own working tree which is implicitly readable.
+ */
+export declare function runShellCommand(args: ShellRunArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/source-traceability.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface SourceTraceabilityGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runSourceTraceabilityGate(args: SourceTraceabilityGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/tests.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface TestsGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runTestsGate(args: TestsGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-gates/typecheck.d.ts

@@ -0,0 +1,6 @@
+import type { GateRunResult } from '../verification-runner';
+export interface TypecheckGateArgs {
+    cwd: string;
+    timeoutMs: number;
+}
+export declare function runTypecheckGate(args: TypecheckGateArgs): Promise<GateRunResult>;

package/dist/local-executor/verification-runner.d.ts

@@ -0,0 +1,28 @@
+import type { ClassAEmitter, ClassAEmitterContext, VerificationGateKind, VerificationResultPayload } from './class-a-emit';
+export declare const DEFAULT_GATE_TIMEOUT_MS = 300000;
+export declare const TIMEOUT_EXIT_CODE = 124;
+export declare const SUMMARY_CAP_BYTES = 4096;
+export interface VerificationGateRequest {
+    gateId: string;
+    taskId: string;
+    sessionId: string;
+    gateKinds: VerificationGateKind[];
+    cwd: string;
+    timeoutMsOverride?: number;
+}
+export interface GateRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut?: boolean;
+}
+export interface VerificationRunnerDeps {
+    emitter: ClassAEmitter;
+    classAContext: ClassAEmitterContext;
+    nowMs?: () => number;
+    onResultEmitted?: (result: VerificationResultPayload) => void;
+}
+export declare function runVerificationGates(req: VerificationGateRequest, deps: VerificationRunnerDeps): Promise<VerificationResultPayload[]>;
+export declare function truncateUtf8Safe(input: string, maxBytes: number): string;
+export declare const NO_OP_PASS: GateRunResult;

package/dist/local-executor/wb2-review-bundle.d.ts

@@ -0,0 +1,59 @@
+/**
+ * §2.6 — a single conflicted path rendered to concrete 3-way CONTENT for the
+ * reviewer prompt. Each side is either decoded text, a per-side snippet (head+tail
+ * with a truncation marker), or a placeholder line (`[absent…]`/`[binary…]`/
+ * `[non-UTF-8…]`). Additive — absent ⇒ today's bare base→tip diff.
+ */
+export interface RenderedConflict {
+    path: string;
+    /** Rendered content OR a placeholder. base = the merge-base side. */
+    base: string;
+    /** integration-tip side (`ours`). */
+    ours: string;
+    /** incoming-track side (`theirs`). */
+    theirs: string;
+}
+/** §2.6 — one track's intent diff (base → trackTip), already byte-bounded. */
+export interface TrackIntentDiff {
+    trackIndex: number;
+    implementorAgent?: string;
+    /** unified base→trackTip diff (byte-bounded by `readDiffHermetic`). */
+    diff: string;
+}
+/** §2.6 — the rendered intent bundle handed to the dispatcher (additive callback fields). */
+export interface RenderedTier2Bundle {
+    conflictBundle: readonly RenderedConflict[];
+    trackIntentDiffs: readonly TrackIntentDiff[];
+}
+/** §2.6 (locked) byte budgets. The aggregate ceiling must clear the 512 KiB diff with headroom. */
+export declare const WAVE_B_TIER2_MAX_BUNDLE_BYTES: number;
+export declare const WB2_BUNDLE_PER_SIDE_MAX_BYTES: number;
+export declare const WB2_INTENT_DIFF_MAX_BYTES: number;
+/**
+ * Render ONE side of a conflict (already-fetched bytes) to prompt-safe text under
+ * the per-side cap. NEVER emits raw bytes for a binary / non-UTF-8 / absent side —
+ * a placeholder line instead (Q-BINARY locked). A side over the per-side cap is
+ * snippet-trimmed head+tail with an explicit `[…truncated N bytes…]` marker
+ * (Q-OVERFLOW locked — the ONLY truncate-with-marker affordance).
+ *
+ * @param bytes the side's raw blob bytes, or `null` when the path is absent on this side.
+ * @param oid   the side's blob OID (for the binary/non-UTF-8 placeholder), if known.
+ */
+export declare function renderConflictSide(bytes: Buffer | null, oid: string | undefined, perSideMaxBytes?: number): string;
+/**
+ * Render the §2.6 bundle into prompt sections, appended AFTER the base→tip diff
+ * block. Returns `''` when the bundle is empty/absent (graceful degrade → today's
+ * behavior). Pure string assembly — no overflow decision here (the dispatcher owns
+ * the aggregate-ceiling fail-closed check, see {@link bundleSectionsOverBudget}).
+ */
+export declare function renderTier2BundleSections(bundle: {
+    conflictBundle?: readonly RenderedConflict[];
+    trackIntentDiffs?: readonly TrackIntentDiff[];
+}): string;
+/**
+ * The LOCK fail-closed aggregate check: TRUE iff the rendered diff + bundle sections
+ * exceed the aggregate ceiling. The dispatcher fails closed (NO-PROMOTE) when true —
+ * the per-side snippet trim keeps individual sides under the per-side cap, but the
+ * AGGREGATE never silently drops a whole conflict or intent diff to fit (§2.6 line 108).
+ */
+export declare function bundleSectionsOverBudget(diff: string, bundleSections: string, maxBundleBytes?: number): boolean;