opencode-swarm 7.144.3 → 7.144.5

package/dist/mutation/engine.d.ts

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { resolveExecutableFromPath, runExternalTool } from '../utils/external-tool-runner.js';
+import { resolveGitExecutable } from '../utils/git-executable.js';
 export type MutationOutcome = 'killed' | 'survived' | 'timeout' | 'cancelled' | 'error' | 'equivalent' | 'skipped';
 /**
  * Known test runner executables permitted as the first element of testCommand.
@@ -84,6 +85,16 @@ export declare const _internals: {
     runCommand: MutationCommandRunner;
     runExternalTool: typeof runExternalTool;
     resolveExecutableFromPath: typeof resolveExecutableFromPath;
+    /**
+     * Test seam for git binary resolution (issue #2236 hardening, lane C1b) —
+     * used ONLY by the two `executable: 'git'` sites in `executeMutation`
+     * (apply / revert). Deliberately NOT used by `runMutationCommand`'s
+     * caller-supplied `args.executable` path (see the doc comment above
+     * `runMutationCommand`) — that path stays on `resolveExecutableFromPath`
+     * so the friendly "git is not installed" message (keyed on
+     * `args.executable === 'git'`) keeps working for `git`-flavored callers.
+     */
+    resolveGitExecutable: typeof resolveGitExecutable;
 };
 export declare function executeMutation(patch: MutationPatch, testCommand: string[], testFiles: string[], workingDir: string, options?: MutationExecutionOptions): Promise<MutationResult>;
 export declare function computeReport(results: MutationResult[], durationMs: number, budgetMs?: number): MutationReport;

package/dist/observability/catalog.d.ts

@@ -1,13 +1,15 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 42 entries, matching the `TelemetryEvent` union at
- * `src/telemetry.ts:15-91`. Thirty-eight predate the #2029 contract; the 39th is
+ * Exactly 43 entries, matching the `TelemetryEvent` union at
+ * `src/telemetry.ts:15-92`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
- * type system), and the 40th is `close_archive_result` (issue #2030 — the
- * structured close/archive result event). The 41st is the bounded diagnostic
+ * type system), the 40th is `close_archive_result` (issue #2030 — the
+ * structured close/archive result event), the 41st is the bounded diagnostic
  * projection of authoritative knowledge-receipt transitions (issue #2031).
- * These late additions are instances of
+ * The 42nd is the human-only `knowledge_maintenance` quarantine audit
+ * (issue #2033), and the 43rd is the aggregate `context_pruned` transcript
+ * mutation audit. These late additions are instances of
  * the defect class this contract exists to close: an event kind entering the
  * stream with no registration.
  *
@@ -62,7 +64,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 42 entries today, and that is a truthful statement about
+     * `false` for all 43 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

package/dist/review/diff-source.d.ts

@@ -8,6 +8,7 @@
  */
 import * as fs from 'node:fs';
 import { bunSpawn } from '../utils/bun-compat.js';
+import { resolveGitExecutableAsync } from '../utils/git-executable.js';
 export interface InclusiveLineRange {
     start: number;
     end: number;
@@ -130,5 +131,6 @@ export declare const _internals: {
     fstatBigIntSync: (fd: number) => fs.BigIntStats;
     readSync: typeof fs.readSync;
     closeSync: typeof fs.closeSync;
+    resolveGitExecutable: typeof resolveGitExecutableAsync;
 };
 export {};

package/dist/sandbox/capability-probe.d.ts

@@ -36,6 +36,27 @@ export interface SandboxCapability {
     /** Error message from the probe, if any. */
     error?: string;
 }
+/** Reset the session-lifetime capability cache. Test-only. */
+export declare function _resetCapabilityCache(): void;
+/**
+ * Wraps a probe command in an AbortController timeout.
+ *
+ * @param cmd     Command binary to run.
+ * @param args    Arguments to pass.
+ * @param ms      Timeout in milliseconds.
+ * @returns A promise that resolves to the captured stdout string, or rejects on timeout / error.
+ */
+declare function withProbeTimeout(cmd: string, args: string[], ms: number): Promise<string>;
+/**
+ * DI seam for testability. Exposes withProbeTimeout so tests can simulate
+ * exit-0/exit-nonzero/ENOENT probe outcomes for every platform's probe
+ * (including darwin) without requiring the real binary on the host running
+ * the tests. See src/sandbox/macos/sandbox-exec-executor.ts's _internals for
+ * the sibling sync-probe seam.
+ */
+export declare const _internals: {
+    withProbeTimeout: typeof withProbeTimeout;
+};
 /**
  * Detects the availability of OS-native sandbox mechanisms.
  *
@@ -67,3 +88,4 @@ export declare class SandboxCapabilityProbe {
      */
     detect(): Promise<SandboxCapability>;
 }
+export {};

package/dist/sandbox/executor.d.ts

@@ -54,6 +54,21 @@ export interface SandboxExecutor {
  * failures on platforms where they don't exist.
  */
 export declare function getExecutor(): Promise<SandboxExecutor | null>;
+/**
+ * Set whether the macOS sandbox-exec mechanism may be activated. Called
+ * once from `createToolBeforeHandler` (src/hooks/guardrails/tool-before.ts)
+ * using the already-resolved `GuardrailsConfig`, at guardrails hook
+ * registration — which runs at plugin init, before the first bash tool call
+ * can trigger `getExecutor()`. When false (the default), `getExecutor()`
+ * behaves exactly as it did before F6: it resolves to `null` and every
+ * consumer (tool-before's `applySandboxExecution`, `diagnose-service`,
+ * guardrails/index) observes the identical fail-open "executor not
+ * available" state, so activation stays byte-identical to today until this
+ * is explicitly turned on.
+ */
+export declare function setMacOSSandboxPolicy(enabled: boolean): void;
+/** @internal test seam — read the current policy without going through config. */
+export declare function _getMacOSSandboxPolicyForTest(): boolean;
 /**
  * Reset the cached executor — useful for testing.
  * @internal

package/dist/sandbox/linux/bubblewrap-executor.d.ts

@@ -7,6 +7,11 @@
  * for defense-in-depth within the user namespace.
  */
 import { type SandboxExecutor } from '../executor';
+/**
+ * Resolve the bwrap binary: absolute base-OS path when present, bare-name
+ * (PATH resolution) fallback otherwise. Never throws.
+ */
+declare function resolveBwrapBinary(): string;
 /**
  * Check whether the bwrap binary is present on PATH.
  * Uses spawnSync to probe synchronously without throwing.
@@ -20,6 +25,7 @@ declare function probeBwrap(): boolean;
  */
 export declare const _internals: {
     probeBwrap: typeof probeBwrap;
+    resolveBwrapBinary: typeof resolveBwrapBinary;
 };
 /**
  * Linux Bubblewrap sandbox executor.

package/dist/sandbox/macos/sandbox-exec-executor.d.ts

@@ -11,19 +11,60 @@
  *   - Read-write access to each scope path and the temp directory
  *   - All other file writes are denied
  */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { type SandboxExecutor } from '../executor';
+/** Resolve the sandbox-exec binary: absolute base-OS path, bare-name fallback. */
+declare function resolveSandboxExecBinary(): string;
+/** Resolve the probe's target command: absolute base-OS path, bare-name fallback. */
+declare function resolveProbeTargetBinary(): string;
+/**
+ * Build the SBPL profile used ONLY for availability probing.
+ *
+ * F6a item 2 (issue #2236): this deliberately shares the same primitives and
+ * ordering as buildSandboxProfile's production profile — a blanket
+ * `(deny file-write*)` followed by a scoped `(allow file-write* (subpath …))`,
+ * plus a `(setenv …)`/`(unsetenv …)` pair (F6b) — so that probe success
+ * implies the production profile's primitives actually parse under this
+ * host's sandbox-exec. A trivial `(allow default)`-only probe would pass
+ * even when the production profile is unparseable, which is the exact
+ * probe-passes/production-fails failure mode this guards against.
+ */
+declare function buildProbeProfile(tempDir: string): string;
 /**
  * Check whether the sandbox-exec binary is present and functional.
  * Uses spawnSync to probe synchronously without throwing.
+ *
+ * F6 (issue #2236 RC2): sandbox-exec(8) has NO `--version` flag — its
+ * synopsis is `sandbox-exec [-f file | -n name | -p string] [-D k=v]
+ * command [args...]` (BSD getopt, short options only). The previous probe
+ * invoked `sandbox-exec --version`, which is consumed as an invalid option
+ * and fails on EVERY macOS host regardless of whether Seatbelt actually
+ * works. The corrected probe runs a real invocation
+ * (`sandbox-exec -p <profile> <target>`) and gates on **exit code 0 ONLY**.
+ * stderr is deliberately never consulted — modern macOS prints a
+ * deprecation notice to stderr on every sandbox-exec call, and that is not
+ * a failure. Empty stdout with exit 0 IS success (sandbox-exec prints
+ * nothing on a clean run of `true`).
  */
 declare function probeSandboxExec(): boolean;
+declare function probeSandboxExecMemoized(): boolean;
+/** Clear the probe memo. Test-only — production never needs to reset it mid-process. */
+declare function resetProbeMemo(): void;
 /**
  * DI seam for testability. Exposes probeSandboxExec so tests can simulate
  * ENOENT / EACCES / ENOSPC error conditions without requiring a real sandbox-exec binary.
  */
 export declare const _internals: {
     probeSandboxExec: typeof probeSandboxExec;
+    probeSandboxExecMemoized: typeof probeSandboxExecMemoized;
+    resetProbeMemo: typeof resetProbeMemo;
     buildSandboxProfile: typeof buildSandboxProfile;
+    buildProbeProfile: typeof buildProbeProfile;
+    resolveSandboxExecBinary: typeof resolveSandboxExecBinary;
+    resolveProbeTargetBinary: typeof resolveProbeTargetBinary;
+    exists: typeof existsSync;
+    spawnSync: typeof spawnSync;
 };
 /**
  * Build a sandbox-exec profile string for the given scope paths, temp dir, and optional env overrides.

package/dist/sast/semgrep.d.ts

@@ -16,13 +16,12 @@ export interface SemgrepOptions {
     timeoutMs?: number;
     /** Working directory for Semgrep execution */
     cwd?: string;
-    /** Language identifier for --lang flag (used with useAutoConfig) */
-    lang?: string;
     /** When true, use --config auto instead of local rulesDir (for profile-driven languages) */
     useAutoConfig?: boolean;
     /** Host/tool cancellation propagated to the shared subprocess runner. */
     abortSignal?: AbortSignal;
 }
+export type SemgrepFailureKind = 'process_exit' | 'timeout' | 'cancelled' | 'output_limit' | 'spawn_error' | 'invalid_output' | 'scan_error' | 'unexpected';
 /**
  * Result from Semgrep execution
  */
@@ -33,6 +32,8 @@ export interface SemgrepResult {
     findings: SastFinding[];
     /** Error message if Semgrep failed */
     error?: string;
+    /** Machine-readable category for an available scanner failure. */
+    failure_kind?: SemgrepFailureKind;
     /** Engine label for the findings */
     engine: 'tier_a' | 'tier_a+tier_b';
 }

package/dist/telemetry.d.ts

@@ -1,6 +1,6 @@
 import { createObservation, toLegacyTelemetryLine } from './observability/index.js';
 import type { DelegationCostFields } from './services/cost-accounting.js';
-export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'gate_parse_error' | 'reviewer_gate_decision' | 'phase_changed' | 'budget_updated' | 'context_pruned' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'no_op_strong_warning' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'plan_md_write_failed' | 'snapshot_failed' | 'gate_denial_loop'
 /**
  * Issue #2063 B5 — an ARMED execution episode reached the advisory rung:
  * `execution_stall_warn_calls` tool calls with no delegation completion, no
@@ -116,6 +116,22 @@ export declare const telemetry: {
     reviewerGateDecision(sessionId: string, taskId: string, blocked: boolean, reasonCode: ReviewerGateReasonCode, evidenceKind: ReviewerGateEvidenceKind): void;
     phaseChanged(sessionId: string, oldPhase: number, newPhase: number): void;
     budgetUpdated(sessionId: string, budgetPct: number, agentName: string): void;
+    contextPruned(data: {
+        sessionId: string;
+        agentName: string;
+        trigger: "agent_switch" | "critical_threshold";
+        usageSource: "provider" | "estimated";
+        beforeTokens: number;
+        afterTokens: number;
+        modelLimit: number;
+        maskedMessages: number;
+        maskedToolParts: number;
+        maskedTokensFreed: number;
+        prunedMessages: number;
+        prunedTextParts: number;
+        prunedToolParts: number;
+        prunedTokensFreed: number;
+    }): void;
     modelFallback(sessionId: string, agentName: string, fromModel: string, toModel: string, reason: string): void;
     hardLimitHit(sessionId: string, agentName: string, limitType: string, value: number): void;
     revisionLimitHit(sessionId: string, agentName: string): void;

package/dist/tools/checkpoint.d.ts

@@ -1,6 +1,7 @@
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import { tryAcquireLock } from '../parallel/file-locks.js';
 import { loadPlan } from '../plan/manager.js';
+import { resolveGitExecutable } from '../utils/git-executable.js';
 export declare const _internals: {
     tryAcquireLock: typeof tryAcquireLock;
     loadPlan: typeof loadPlan;
@@ -9,6 +10,16 @@ export declare const _internals: {
     findCommitByExactSubject: typeof findCommitByExactSubject;
     stageAllExcludingSwarm: typeof stageAllExcludingSwarm;
     afterTaskEligibilityRead?: (directory: string, taskId: string) => Promise<void>;
+    /**
+     * Issue #2236 hardening (F1/F4/F5) — resolves the absolute git executable
+     * path instead of spawning the bare `'git'` name. Exposed for test
+     * injection (mirrors `src/git/branch.ts`'s `_internals.resolveGitExecutable`
+     * convention) so a test that mocks `node:child_process` wholesale to drive
+     * `gitExec`'s retry/classification logic can stub a fixed value instead of
+     * having the real candidate-probing loop consume the same mocked
+     * `spawnSync` call slots the test is asserting on.
+     */
+    resolveGitExecutable: typeof resolveGitExecutable;
 };
 declare function stageAllExcludingSwarm(directory: string): void;
 declare function gitExec(args: string[], cwd: string): string;

package/dist/tools/complexity-hotspots.d.ts

@@ -1,2 +1,17 @@
 import type { tool } from '@opencode-ai/plugin';
+import { bunSpawn } from '../utils/bun-compat';
+import { resolveGitExecutable } from '../utils/git-executable.js';
+/**
+ * Test-only seam for the `bunSpawn` call this file makes. Lets tests inject a
+ * synthetic subprocess (e.g. one with `spawnError` set) without monkey-patching
+ * the `Bun.spawn` global — see #2236 Sweep A, FIX 1.
+ *
+ * `resolveGitExecutable` (issue #2236 hardening, F1/F4/F5) resolves the
+ * absolute git executable path instead of spawning the bare `'git'` name;
+ * exposed here so tests can inject a deterministic value.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+    resolveGitExecutable: typeof resolveGitExecutable;
+};
 export declare const complexity_hotspots: ReturnType<typeof tool>;

package/dist/tools/context-status.d.ts

@@ -2,7 +2,9 @@
  * Context Status Tool
  *
  * Read-only tool that reports current context-window headroom for the active
- * session. Derives messages from the runtime session context (via
+ * session. Returns both the measured usage and the `usageSource`
+ * (`provider` prompt accounting when available, otherwise `estimated`).
+ * Derives messages from the runtime session context (via
  * `swarmState.opencodeClient.session.messages`) and resolves thresholds from
  * the plugin config, mirroring the active `createContextBudgetHandler` hook's
  * behavior exactly — including strict `>` boundary semantics (exact threshold
@@ -12,6 +14,7 @@
  * Works whether `context_budget.enabled` is true or false.
  */
 import { loadPluginConfig } from '../config';
+import { type ContextUsageSource } from '../hooks/context-usage';
 import { createSwarmTool } from './create-tool';
 /**
  * Shape of a message's info block.
@@ -47,8 +50,10 @@ export interface ContextMessage {
  * Result returned by the context_status tool.
  */
 export interface ContextStatusResult {
-    /** Estimated tokens used across all text parts in the session */
+    /** Provider-accounted or estimated tokens used across the session */
     tokensUsed: number;
+    /** Whether usage came from provider prompt accounting or a bounded estimate */
+    usageSource: ContextUsageSource;
     /** Resolved model context limit in tokens */
     modelLimit: number;
     /** Ratio of tokens-used to model-limit (0.0 – 1.0+) */
@@ -101,7 +106,8 @@ declare function computeContextHeadroom(messages: ContextMessage[], warnThreshol
  *
  * No arguments required — the tool queries current state automatically.
  *
- * Returns JSON string with tokensUsed, modelLimit, usagePercent, thresholdCrossed, modelId, provider.
+ * Returns JSON with tokensUsed, usageSource, modelLimit, usagePercent,
+ * thresholdCrossed, modelId, and provider.
  */
 export { computeContextHeadroom };
 export declare const context_status: ReturnType<typeof createSwarmTool>;

package/dist/tools/diff-summary.d.ts

@@ -1,5 +1,16 @@
+import * as child_process from 'node:child_process';
 import { type ChangeCategory, type RiskLevel } from '../diff/semantic-classifier.js';
+import { resolveGitExecutableAsync } from '../utils/git-executable.js';
 import { createSwarmTool } from './create-tool';
+export declare const _internals: {
+    execFile: typeof child_process.execFile;
+    resolveGitExecutableAsync: typeof resolveGitExecutableAsync;
+    execGit: typeof execGit;
+};
+declare function execGit(workingDir: string, args: string[], options?: {
+    timeout?: number;
+    maxBuffer?: number;
+}): Promise<string>;
 export interface DiffSummaryArgs {
     files: string[];
     classification?: ChangeCategory;
@@ -10,3 +21,4 @@ export interface DiffSummaryArgs {
  * to produce a filtered SemanticDiffSummary.
  */
 export declare const diff_summary: ReturnType<typeof createSwarmTool>;
+export {};

package/dist/tools/dispatch-lanes.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { type BackgroundDelegationRecord } from '../background/pending-delegations.js';
+import { type BackgroundDelegationRecord, type BackgroundDelegationWorkflowLaneRecovery } from '../background/pending-delegations.js';
 import { resolveExactMergeBaseAsync, resolvePrWorkflowRevisionDigestAsync } from '../background/workspace-snapshot.js';
-import { type PrReviewDepthTier } from '../hooks/pr-workflow-gate.js';
+import { type PrReviewDepthTier, validatePrWorkflowTransportRecovery } from '../hooks/pr-workflow-gate.js';
 import { buildLaneOrientationBlock } from '../hooks/repo-graph-injection.js';
 import { createParallelDispatcher } from '../parallel/dispatcher/parallel-dispatcher.js';
 import { createSwarmTool } from './create-tool.js';
@@ -126,6 +126,12 @@ export interface DispatchLaneResult {
     output_artifact_error?: string;
     transcript_incomplete?: boolean;
     message_count?: number;
+    salvaged_workflow_lanes?: string[];
+    salvaged_workflow_lane_recoveries?: Array<{
+        workflow_lane: string;
+        kind: BackgroundDelegationWorkflowLaneRecovery['kind'];
+        reason: string;
+    }>;
     /**
      * Set to true when this lane's `output` preview was withheld because an
      * identical preview (same batch, lane, and result digest) was already
@@ -251,6 +257,11 @@ export interface SessionOps {
         data?: Array<{
             info?: {
                 role?: string;
+                time?: {
+                    completed?: number;
+                };
+                finish?: string;
+                error?: unknown;
             };
             parts?: Array<{
                 type: string;
@@ -286,6 +297,7 @@ export declare const _internals: {
     createParallelDispatcher: typeof createParallelDispatcher;
     resolvePrWorkflowRevisionDigestAsync: typeof resolvePrWorkflowRevisionDigestAsync;
     resolveExactMergeBaseAsync: typeof resolveExactMergeBaseAsync;
+    validatePrWorkflowTransportRecovery: typeof validatePrWorkflowTransportRecovery;
     now: () => number;
     sleep: (ms: number) => Promise<void>;
 };
@@ -302,6 +314,7 @@ export declare const _test_exports: {
     formatError: typeof formatError;
     nextCollectPollInterval: typeof nextCollectPollInterval;
     promptHash: typeof promptHash;
+    reserveCollectionLaneCallBudgets: typeof reserveCollectionLaneCallBudgets;
     isRetryableSessionCreateFailure: typeof isRetryableSessionCreateFailure;
     DispatchLanesArgsSchema: z.ZodObject<{
         lanes: z.ZodArray<z.ZodObject<{
@@ -386,6 +399,7 @@ export declare const _test_exports: {
      */
     resetDeliveredLaneOutputs: () => void;
     recordToLaneResult: typeof recordToLaneResult;
+    prReviewLaneResponseBudgetChars: typeof prReviewLaneResponseBudgetChars;
 };
 type ReadOnlyToolPermissions = Record<string, false> & {
     write: false;
@@ -403,6 +417,11 @@ declare function isRetryableSessionCreateFailure(error: unknown): boolean;
 declare function extractAssistantTranscript(messages: Array<{
     info?: {
         role?: string;
+        time?: {
+            completed?: number;
+        };
+        finish?: string;
+        error?: unknown;
     };
     parts?: Array<{
         type: string;
@@ -412,6 +431,13 @@ declare function extractAssistantTranscript(messages: Array<{
     text: string;
     messageCount: number;
     transcriptIncomplete: boolean;
+    terminalAssistantProof: boolean;
+};
+declare function reserveCollectionLaneCallBudgets(deadline: number, remainingLaneCount: number, hasStatusCall: boolean, hasRevisionDigestCall?: boolean): {
+    laneBudgetMs: number;
+    statusBudgetMs: number;
+    messagesBudgetMs: number;
+    revisionDigestBudgetMs: number;
 };
 declare function nextCollectPollInterval(currentMs: number): number;
 declare function buildCollectResult(batchId: string, records: BackgroundDelegationRecord[], includePending: boolean, deliveryContext?: {
@@ -472,6 +498,13 @@ declare function applyExplorerFormatSuffix(lanes: DispatchLaneSpec[], options?:
     failClosed?: boolean;
     mode?: string;
 }): ApplyCommonPromptResult;
+/**
+ * #2276: derive the final-response character budget for a PR-review lane from
+ * the lane's owned workload. Returns `undefined` for modes without a derived
+ * budget (the swarm-pr-feedback modes keep their flat
+ * {@link PR_WORKFLOW_PROTOCOL_OUTPUT_MAX_CHARS} guidance).
+ */
+declare function prReviewLaneResponseBudgetChars(mode: string, lane: DispatchLaneSpec): number | undefined;
 declare function applyPrWorkflowPromptContract(lanes: DispatchLaneSpec[], options: {
     mode?: string;
     prHeadSha?: string;

package/dist/tools/gh-evidence.d.ts

@@ -5,7 +5,23 @@ interface GhBinaryCandidateOptions {
     platform?: NodeJS.Platform;
 }
 export declare function resolveGhBinaryCandidates(options?: GhBinaryCandidateOptions): string[];
-declare function resolveGhBinary(): string | null;
+/**
+ * Resolve the `gh` binary to invoke. Exported (issue #2236 hardening, lane
+ * C1b) so other call sites that need a `gh` executable — e.g. `src/git/pr.ts`,
+ * `src/commands/pr-monitor-status.ts` — reuse this resolver instead of
+ * spawning a bare `'gh'` literal or inventing a second gh resolver. Returns
+ * `null` when no candidate is found; callers should fall back to the bare
+ * `'gh'` literal (mirrors `resolveGitExecutable()`'s "never regress a working
+ * host" fallback in `src/utils/git-executable.ts`).
+ */
+export declare function resolveGhBinary(): string | null;
+/**
+ * TEST-ONLY seam (issue #2236 FR-006 ratchet fix) — NOT a production API, do
+ * not call from `src/`. Sets the pin `resolveGhBinary()` checks first; pass
+ * `null` to simulate "no `gh` candidate found". Mirrors
+ * `__seedGitExecutableForTests` in `src/utils/git-executable.ts`.
+ */
+export declare function __seedGhBinaryForTests(value: string | null): void;
 export declare const gh_evidence: ToolDefinition;
 export declare const _internals: {
     resolveGhBinaryCandidates: typeof resolveGhBinaryCandidates;

package/dist/tools/knowledge-receipt.d.ts

@@ -17,8 +17,8 @@ import { createSwarmTool } from './create-tool.js';
 declare const ignoredItem: z.ZodObject<{
     id: z.ZodString;
     reason: z.ZodEnum<{
-        stale: "stale";
         other: "other";
+        stale: "stale";
         superseded: "superseded";
         unsafe: "unsafe";
         too_generic: "too_generic";

package/dist/tools/pkg-audit.d.ts

@@ -1,2 +1,15 @@
 import type { tool } from '@opencode-ai/plugin';
+import { bunSpawn } from '../utils/bun-compat';
+/**
+ * Test-only seam for the `bunSpawn` calls `runNpmAudit` and `runCargoAudit`
+ * make. Lets tests inject a synthetic subprocess (e.g. one with `spawnError`
+ * set) without monkey-patching the `Bun.spawn` global — see #2236 Sweep A,
+ * FIX 2. These two route through the seam because both had a path where a
+ * failed spawn could be reported as a completed scan; the remaining audit
+ * functions gate strictly on a non-zero exit and were dispositioned
+ * SAFE-EXIT-CHECK by that sweep.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+};
 export declare const pkg_audit: ReturnType<typeof tool>;

package/dist/tools/pre-check-batch.d.ts

@@ -9,6 +9,7 @@ import { saveEvidence } from '../evidence/manager.js';
 import { runExternalTool } from '../utils/external-tool-runner';
 import type { LintResult, ResolvedLinterCommand } from './lint';
 import { detectResolvedLinter } from './lint';
+import { resolveGatePreamble } from './phase-complete/gates/gate-helpers';
 import type { QualityBudgetResult } from './quality-budget';
 import { qualityBudget } from './quality-budget';
 import type { SastScanFinding, SastScanResult } from './sast-scan';
@@ -27,6 +28,8 @@ export declare const _internals: {
     runLintOnFiles: typeof runLintOnFiles;
     platform: () => NodeJS.Platform;
     serializePreCheckResult: typeof serializePreCheckResult;
+    resolveGatePreamble: typeof resolveGatePreamble;
+    runPreCheckBatch: typeof runPreCheckBatch;
     MAX_COMBINED_BYTES: number;
 };
 export interface PreCheckBatchInput {
@@ -46,6 +49,8 @@ export interface PreCheckBatchInput {
      * with capture_baseline:true.
      */
     phase?: number;
+    /** Effective QA-profile value derived internally by the public tool boundary. */
+    sast_enabled?: boolean;
 }
 export interface ToolResult<T> {
     /** Whether the tool was executed */
@@ -76,6 +81,10 @@ export interface PreCheckBatchResult {
     total_duration_ms: number;
     /** Pre-existing SAST findings on unchanged lines, requiring reviewer triage */
     sast_preexisting_findings?: SastScanFinding[];
+    /** Optional Semgrep exited nonzero with no findings; SAST coverage is incomplete. */
+    sast_degraded?: boolean;
+    /** SAST was intentionally disabled by the effective QA profile. */
+    sast_skipped?: boolean;
 }
 /**
  * Serialize the public result below the decoder's stricter byte ceiling. When

package/dist/tools/prepare-pr-workflow-checkout.d.ts

@@ -22,6 +22,7 @@ declare function runGit(directory: string, args: string[], options?: {
 }): Promise<{
     exitCode: number;
     stdout: string;
+    spawnError?: Error | null;
 }>;
 declare function readBoundedGitStdout(stream: {
     getReader(): ReadableStreamDefaultReader<Uint8Array>;

package/dist/tools/sast-scan.d.ts

@@ -40,6 +40,8 @@ export interface SastScanResult {
     verdict: EvidenceVerdict;
     /** Validation error when the requested scan cannot safely run */
     error?: string;
+    /** Machine-readable failure category for gate consumers. */
+    failure_kind?: SastFailureKind;
     /** Array of security findings */
     findings: SastScanFinding[];
     /** Summary information */
@@ -71,6 +73,7 @@ export interface SastScanResult {
     /** True when pre_existing_findings were truncated to fit result limits */
     truncated_pre_existing?: boolean;
 }
+export type SastFailureKind = 'semgrep_process_exit' | 'semgrep_timeout' | 'semgrep_cancelled' | 'semgrep_output_limit' | 'semgrep_spawn_error' | 'semgrep_invalid_output' | 'semgrep_scan_error' | 'semgrep_unexpected' | 'semgrep_unclassified' | 'coverage' | 'cancelled' | 'invalid_input';
 export interface SastScanFinding {
     rule_id: string;
     severity: 'critical' | 'high' | 'medium' | 'low';