opencode-swarm 7.144.4 → 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/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/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/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

@@ -399,6 +399,7 @@ export declare const _test_exports: {
      */
     resetDeliveredLaneOutputs: () => void;
     recordToLaneResult: typeof recordToLaneResult;
+    prReviewLaneResponseBudgetChars: typeof prReviewLaneResponseBudgetChars;
 };
 type ReadOnlyToolPermissions = Record<string, false> & {
     write: false;
@@ -497,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/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/utils/bun-compat.d.ts

@@ -25,6 +25,7 @@
  *     present and falls back to a stable djb2-derived 32-bit hash on Node.
  */
 import { spawn as nodeSpawn } from 'node:child_process';
+import * as fsSync from 'node:fs';
 /**
  * Whether the current runtime is Bun. Cached at first call — every subsequent
  * call is a single property access.
@@ -118,9 +119,16 @@ export interface BunCompatSubprocess {
     exitCode: number | null;
     readonly signalCode?: NodeJS.Signals | null;
     /**
-     * Asynchronous process-creation failure reported by Node's ChildProcess
-     * `error` event (for example ENOENT). Bun reports equivalent failures by
-     * throwing from `Bun.spawn`, so this is populated only by the Node fallback.
+     * Process-creation failure (for example ENOENT), reported as a **value**
+     * on every runtime.
+     *
+     * The Node fallback populates it from ChildProcess's `error` event. Bun
+     * reports the same failures by throwing synchronously from `Bun.spawn`;
+     * issue #2236 showed that throw escaping uncaught to a tool boundary and
+     * surfacing a raw `ENOENT ... posix_spawn 'git'` to the user. The Bun path
+     * is now normalised *down* to this contract — the throw is caught and
+     * exposed here — so process-creation failures have no exit code, are
+     * described by `spawnError`, and `bunSpawn` never throws.
      */
     readonly spawnError?: Error | null;
     kill(signal?: NodeJS.Signals | number): void;
@@ -133,7 +141,76 @@ export declare const _internals: {
     cwd: () => string;
     spawnTaskkill: (args: string[], options: Parameters<typeof nodeSpawn>[2]) => import("node:child_process").ChildProcess;
     createProcessTreeKiller: typeof createProcessTreeKiller;
+    /**
+     * Test seam for the spawn-`cwd` probe. Lets a test drive the `EACCES`
+     * branch on hosts (Windows) where an unreadable directory cannot be created
+     * without elevation, instead of skipping the case.
+     */
+    statSync: (target: string) => fsSync.Stats;
 };
+/** Why a spawn `cwd` was rejected before the child was ever created. */
+export type SpawnCwdFailureReason = 'missing' | 'not-directory';
+/**
+ * Raised as a **value**, never thrown: `bunSpawn`/`bunSpawnSync` surface it
+ * through the runtime's existing failure contract (`spawnError` plus a
+ * non-zero `exited`), and `runGit` converts it into its typed failure result.
+ * Throwing it would escalate previously-safe call sites into unhandled
+ * synchronous throws — the exact leak class this change removes.
+ */
+export declare class SpawnCwdMissingError extends Error {
+    readonly name = "SpawnCwdMissingError";
+    /** Kept ENOENT so existing `code`-sniffing call sites keep working. */
+    readonly code = "ENOENT";
+    readonly cwd: string;
+    readonly reason: SpawnCwdFailureReason;
+    readonly executable: string;
+    constructor(cwd: string, reason: SpawnCwdFailureReason, executable: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Observable state of a spawn `cwd`. */
+export type SpawnCwdState = 
+/** Present and a directory — a spawn ENOENT here really is the binary. */
+'directory'
+/** Definitely absent. */
+ | 'missing'
+/** Present but not a directory (a file, for example). */
+ | 'not-directory'
+/** `stat` refused (`EACCES`/`EPERM`) — we cannot tell. */
+ | 'unreadable'
+/** `stat` failed for some other reason — we cannot tell. */
+ | 'unknown';
+/**
+ * Inspects a spawn `cwd` with `statSync(...).isDirectory()`.
+ *
+ * `existsSync` is deliberately NOT used: it returns `true` for a `cwd` that is
+ * a regular *file* (the spawn then fails `ENOTDIR` on POSIX / `ENOENT` on
+ * Windows) and `false` when `stat` fails with `EACCES` (the directory is in
+ * fact present). Both would be misclassified.
+ *
+ * Verified rather than assumed: a **relative** `cwd` is safe (the stat and the
+ * child resolve against the same parent cwd), and a **symlinked** `cwd` is
+ * safe (`statSync` follows the link, as does the child).
+ */
+export declare function inspectSpawnCwd(cwd: string): SpawnCwdState;
+/**
+ * Returns a typed error when `cwd` is *definitely* unusable as a spawn working
+ * directory, `null` otherwise.
+ *
+ * An `unreadable`/`unknown` `cwd` deliberately returns `null`: refusing to
+ * spawn on "I cannot tell" would convert a stat permission quirk into a hard
+ * failure. The spawn proceeds and the OS decides; the classifiers in
+ * `git-binary-missing-error.ts` then report the honest third state.
+ */
+export declare function describeSpawnCwdFailure(cwd: string, executable: string, cause?: unknown): SpawnCwdMissingError | null;
+/** Mutually exclusive classification of a spawn failure. */
+export type SpawnFailureClass = 'binary-missing' | 'cwd-missing' | 'cwd-unreadable' | 'other';
+/**
+ * Single source of truth for the three-way split (issue #2236).
+ * `git-binary-missing-error.ts` re-exports this and its predicates delegate
+ * here, so the wrap below and every caller-side check can never disagree.
+ */
+export declare function classifySpawnFailure(err: unknown, cwd?: string): SpawnFailureClass;
 /**
  * Merges `envOverrides` into the base env (or `process.env` if no base env
  * is given) and returns the resulting record.

package/dist/utils/git-binary-missing-error.d.ts

@@ -1,9 +1,87 @@
-export declare class GitBinaryMissingError extends Error {
+/**
+ * Spawn-failure classification for git (and any other external binary).
+ *
+ * Issue #2236: a spawn that fails with `ENOENT` was previously read as
+ * "the git binary is not on PATH". That is only one of the reasons a spawn
+ * can produce `ENOENT`. When the `cwd` handed to the spawn no longer exists,
+ * libuv reports the *same* code — `ENOENT: no such file or directory,
+ * posix_spawn 'git'` (`uv_spawn` on Windows) — and the misclassification sent
+ * the reported bug down a four-day PATH investigation while git was present
+ * the whole time.
+ *
+ * The discriminator is the `cwd` the caller already holds. Classification is
+ * three-way, never two-way: "I cannot tell" gets its own state and is never
+ * folded into either definite bucket.
+ *
+ * The `cwd` probe itself (`inspectSpawnCwd`, `SpawnCwdMissingError`) lives in
+ * `bun-compat.ts` — that file must stay loadable by bare Node, so it cannot
+ * import from here. It is re-exported below so callers still have one
+ * classification surface.
+ */
+export { classifySpawnFailure, describeSpawnCwdFailure, inspectSpawnCwd, type SpawnCwdFailureReason, SpawnCwdMissingError, type SpawnCwdState, type SpawnFailureClass, } from './bun-compat.js';
+/**
+ * Base type for "git never ran".
+ *
+ * Both subclasses mean the child process was never created, so **nothing may
+ * be inferred from its absence of output**. That distinction is the whole
+ * point: a caller that reads "git produced no result" as a fact about the
+ * repository (for example "this path is not in HEAD") is only entitled to do
+ * so when git actually executed and reported. Callers therefore discriminate
+ * on this base, not on either subclass — a two-way `instanceof` check against
+ * a three-way classification is what re-introduces the #2236 misdiagnosis one
+ * state at a time.
+ */
+export declare class GitUnavailableError extends Error {
+}
+export declare class GitBinaryMissingError extends GitUnavailableError {
     readonly name = "GitBinaryMissingError";
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-export declare function isGitBinaryMissing(err: unknown): err is {
+/** Which of the two `cwd` fault states produced a {@link GitSpawnCwdError}. */
+export type GitSpawnCwdFault = 'missing' | 'unreadable';
+/**
+ * git could not start because its `cwd` was unusable — the #2236 shape.
+ *
+ * Deliberately a *sibling* of {@link GitBinaryMissingError}, never a subclass:
+ * "the working directory is gone" and "git is not installed" are different
+ * facts with different remediations, and the #2236 regression suites assert
+ * that a cwd fault is `not.toBeInstanceOf(GitBinaryMissingError)`.
+ *
+ * The message text is rendered here rather than at each throw site so all four
+ * `execGit`-style call sites (`git/branch.ts`, `tools/checkpoint.ts`,
+ * `hooks/semantic-diff-injection.ts`, `tools/diff-summary.ts`) cannot drift.
+ */
+export declare class GitSpawnCwdError extends GitUnavailableError {
+    readonly name = "GitSpawnCwdError";
+    readonly cwd: string;
+    readonly fault: GitSpawnCwdFault;
+    constructor(cwd: string, fault: GitSpawnCwdFault, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * True when the spawn failed because the executable itself could not be
+ * resolved. Passing the `cwd` the caller already holds is what makes this
+ * answer trustworthy; omitting it preserves the pre-#2236 ENOENT-only
+ * behaviour for call sites that have no cwd to offer.
+ */
+export declare function isGitBinaryMissing(err: unknown, cwd?: string): err is {
+    code?: string;
+};
+/**
+ * True when the spawn failed because `cwd` is gone, or exists but is not a
+ * directory. This is the #2236 failure shape.
+ */
+export declare function isSpawnCwdMissing(err: unknown, cwd: string): err is {
+    code?: string;
+};
+/**
+ * True when `cwd` could not be inspected (`EACCES`/`EPERM`, or an unexpected
+ * stat failure). Never folded into either definite bucket — callers must fail
+ * closed on it rather than assume the directory is gone.
+ */
+export declare function isSpawnCwdUnreadable(err: unknown, cwd: string): err is {
     code?: string;
 };