@yagni-app/code-staging 1.1.6-staging.1438.1 → 1.1.6-staging.1443.1

package/dist/extension/pipeline/invocation.js

@@ -45,9 +45,7 @@ export const CHILD_HONESTY_PREAMBLE = "Never fabricate file paths, file contents
     "rather than presenting a guess as a finding.";
 /** Fill {ticket}/{previous}; an absent var renders as empty string. */
 export function renderTemplate(tmpl, vars) {
-    return tmpl
-        .replace(/\{ticket\}/g, vars.ticket ?? "")
-        .replace(/\{previous\}/g, vars.previous ?? "");
+    return tmpl.replace(/\{(ticket|previous)\}/g, (_, key) => vars[key] ?? "");
 }
 /**
  * Build the pi passthrough argv for one stage (from `--mode` onward). The

package/dist/extension/pipeline/stages.js

@@ -44,6 +44,10 @@ export const REQUIRED_LENSES = ["correctness"];
 const READ_TOOLS = ["read", "grep", "find", "ls", "bash"];
 /** Full write tools for the worker stages. */
 const WRITE_TOOLS = ["read", "write", "edit", "bash", "grep", "find", "ls"];
+const TICKET_CONTEXT = "Follow the approved plan and its explicit constraints, including approved answers. " +
+    "Prior summaries and review findings do not authorize expanding scope or publication " +
+    "permissions. Report conflicts requiring a scope change for approval.\n\n" +
+    "Ticket context and explicit constraints:\n{ticket}\n\n";
 export const PIPELINE_V1 = [
     {
         id: "map",
@@ -71,7 +75,8 @@ export const PIPELINE_V1 = [
         agent: "worker",
         model: "standard",
         tools: [...WRITE_TOOLS, "ask_yagni", "record_decision"],
-        taskTemplate: "Implement the plan. Write the code against it, and call record_decision " +
+        taskTemplate: TICKET_CONTEXT +
+            "Implement the plan. Write the code against it, and call record_decision " +
             "only for a consequential product-intent or architecture call the plan did " +
             "not settle (never for taste, naming, or formatting).\n\nPlan:\n{previous}",
     },
@@ -80,14 +85,16 @@ export const PIPELINE_V1 = [
         agent: "reviewer",
         model: "peak",
         tools: [...READ_TOOLS, "ask_yagni", "review_business_match"],
-        taskTemplate: "Review the implementation adversarially. Diff/summary of the change:\n{previous}",
+        taskTemplate: TICKET_CONTEXT +
+            "Review the implementation adversarially. Diff/summary of the change:\n{previous}",
     },
     {
         id: "fix",
         agent: "worker",
         model: "standard",
         tools: [...WRITE_TOOLS, "ask_yagni"],
-        taskTemplate: "Reconcile ONLY the blocking review findings against the plan. Leave " +
+        taskTemplate: TICKET_CONTEXT +
+            "Reconcile ONLY the blocking review findings against the plan. Leave " +
             "non-blocking findings alone.\n\nBlocking findings:\n{previous}",
     },
 ];
@@ -197,7 +204,8 @@ export function builderStage(workstream, siblings = []) {
         model: workstream.tier,
         workstream: workstream.name,
         personaClause: builderPersonaClause(workstream, siblings),
-        taskTemplate: `Implement ONLY your workstream of the plan below: "${workstream.name}".\n\n` +
+        taskTemplate: TICKET_CONTEXT +
+            `Implement ONLY your workstream of the plan below: "${workstream.name}".\n\n` +
             `Your workstream: ${workstream.task}\n\n` +
             "Write the code against the plan, staying inside the files you own, and call " +
             "record_decision only for a consequential product-intent or architecture call " +
@@ -216,7 +224,8 @@ export function synthesizerStage() {
         ...implement,
         agent: "synthesizer",
         model: "standard",
-        taskTemplate: "Several builders just finished in parallel in this working tree. Reconcile the " +
+        taskTemplate: TICKET_CONTEXT +
+            "Several builders just finished in parallel in this working tree. Reconcile the " +
             "seams between their changes, address the checker findings and any out-of-claim " +
             "edits below, and write ONE implement summary for the reviewers.\n\n{previous}",
     };
@@ -236,7 +245,8 @@ export const SYNTHESIZER_CALLER_LABEL = `${IMPLEMENT_CALLER_PREFIX}synthesizer`;
 export function synthesizerFixStage(findings) {
     return {
         ...synthesizerStage(),
-        taskTemplate: "Verification failed on the merged tree, and these findings do not sit inside any single " +
+        taskTemplate: TICKET_CONTEXT +
+            "Verification failed on the merged tree, and these findings do not sit inside any single " +
             "workstream's files, so they are yours. Fix ONLY what is listed, then re-write the implement " +
             `summary for the reviewers in the same format.\n\nFindings:\n${findings}`,
     };
@@ -251,7 +261,8 @@ export function fixerStage(workstream, findings, siblings = []) {
     return {
         ...base,
         personaClause: builderPersonaClause(workstream, siblings),
-        taskTemplate: "Verification failed. Fix ONLY the findings below" +
+        taskTemplate: TICKET_CONTEXT +
+            "Verification failed. Fix ONLY the findings below" +
             (workstream ? `, and only inside the files your workstream owns` : "") +
             ". Do not start a fresh pass over the plan and do not fix anything that is not " +
             `listed.\n\nFindings:\n${findings}`,

package/dist/extension/sandbox/bash.d.ts

@@ -62,25 +62,65 @@ export declare function makeSandboxSpawnHook(manager: YagniSandboxManager): Bash
  * when the manager is not initialized (fail-open to plain execution — the
  * permission gate still ran; the sandbox simply is not active).
  *
- * Transient shell-resolution failures (isShellResolutionFailure — srt's 1s
- * `which` spawn timing out under load) are retried once after a short
- * backoff; a second failure surfaces the original error. Any other error
- * propagates immediately, no retry.
+ * Shell-resolution failures (isShellResolutionFailure — srt's 1s `which`
+ * spawn timing out under load) carry two distinct causes that srt collapses
+ * into one message, split here by evidence:
+ *
+ *   - LOAD TIMEOUT (the common case): the attempt took ~1s (the srt hard
+ *     timeout) — `which` itself failed to spawn because the machine is
+ *     saturated. Self-heals (observed sick windows 15–22s, heals within
+ *     ~75s, 10/10 across every recorded incident). Retried on an
+ *     exponential ladder; a ladder that never heals surfaces the HONEST
+ *     transient message (the raw `Shell '…' not found in PATH` is a lie
+ *     for this cause — the shell is right there — and models flail on it).
+ *   - GENUINE MISS (rare): the attempt failed fast (<500ms — `which`
+ *     answers a real "no" in ~4ms, measured) or the shell is an absolute
+ *     path that does not exist. The original error surfaces immediately,
+ *     zero retries — for this cause the message is TRUE and retrying is
+ *     dead time against a config problem.
+ *
+ * Any other error propagates immediately, no retry. Every ladder sleep is
+ * abort-aware (Ctrl+C / tool cancel kills the wait).
  */
 export interface PreWrapRetryOpts {
-    /** Abort the backoff sleep (the tool call's signal). */
+    /** Abort the ladder sleeps (the tool call's signal). */
     signal?: AbortSignal;
-    /** Backoff before the single retry. Tests pass a tiny value to stay fast. */
-    backoffMs?: number;
     /** Instrumentation: fired once, with the retry's terminal outcome. */
     onRetry?: (outcome: "recovered" | "exhausted") => void;
+    /** Retry policy: the default ladder, or the legacy single 2s retry
+     * (background launches — a silent 35s stall on a returns-immediately
+     * call is worse than the error, and bg launches are the highest-load
+     * moments). */
+    retryPolicy?: "ladder" | "single";
+    /** Discriminator threshold: a signature failure whose wrap attempt took
+     * at least this many ms classifies as a load timeout; faster ones are
+     * genuine misses. Default SHELL_RESOLUTION_TRANSIENT_MIN_ELAPSED_MS —
+     * exported and seam-overridable; tests pass 0 to force the ladder path
+     * against instant-throwing fakes, session tests shrink the default. */
+    transientMinElapsedMs?: number;
 }
+/** The honest failure text for an exhausted ladder: says what actually
+ * happened, what it means, and what to do. Exported so tests pin the exact
+ * string. Deliberately contains no EPERM / "Operation not permitted" /
+ * `[sandbox] ` markers — it must never match isSandboxDenialOutput and
+ * poison the escape-consent flow's session denial evidence. */
+export declare const SHELL_RESOLUTION_TRANSIENT_MESSAGE: string;
+/** The discriminator threshold: a signature failure whose wrap attempt
+ * took at least this many ms classifies as a load timeout; faster ones
+ * are genuine misses. The two causes are ~4ms (a real `which` "no") vs
+ * ~1000ms (srt's hard timeout) apart, so the midpoint has wide margins
+ * on both sides. Extracted per the coupled-rollout rule — the riskiest
+ * heuristic of the feature must be independently revertible. */
+export declare const SHELL_RESOLUTION_TRANSIENT_MIN_ELAPSED_MS = 500;
+export declare function _setShellResolutionRetryBackoffsForTest(ms: readonly number[] | null): void;
+export declare function _setShellResolutionSingleRetryBackoffForTest(ms: number | null): void;
+export declare function _setShellResolutionTransientMinElapsedForTest(ms: number | null): void;
 export declare function preWrappedCommand(manager: YagniSandboxManager, command: string, binShell?: string, opts?: PreWrapRetryOpts): Promise<string>;
-export declare function _setShellResolutionRetryBackoffForTest(ms: number | null): void;
-/** srt's transient shell-resolution failure: `Shell '<name>' not found in
- * PATH`, thrown from wrapCommandWithSandbox when which.js's 1s
- * spawnSync('which') times out under load. Self-healing after ~15–30s;
- * preWrappedCommand retries it once. */
+/** srt's shell-resolution failure: `Shell '<name>' not found in PATH`,
+ * thrown from wrapCommandWithSandbox when which.js's 1s spawnSync('which')
+ * times out under load — or genuinely answers "no". preWrappedCommand
+ * splits the two by evidence (see its doc) and retries only the load
+ * timeout, on an exponential ladder. */
 export declare function isShellResolutionFailure(err: unknown): boolean;
 /**
  * Did this command output indicate the OS sandbox DENIED something? The

package/dist/extension/sandbox/bash.js

@@ -21,7 +21,7 @@
  * lessons (process-group kill, stdio release).
  */
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { logEvent } from "../errorSink.js";
 import { scrubSecrets } from "../pipeline/scrubSecrets.js";
 function stripLeadingSafeEnvVars(command) {
@@ -115,73 +115,193 @@ export function makeSandboxSpawnHook(manager) {
         env: { ...ctx.env, ...extraEnv },
     });
 }
+/** The honest failure text for an exhausted ladder: says what actually
+ * happened, what it means, and what to do. Exported so tests pin the exact
+ * string. Deliberately contains no EPERM / "Operation not permitted" /
+ * `[sandbox] ` markers — it must never match isSandboxDenialOutput and
+ * poison the escape-consent flow's session denial evidence. */
+export const SHELL_RESOLUTION_TRANSIENT_MESSAGE = "Transient sandbox shell-resolution timeout — the machine is under load. " +
+    "It self-heals, typically within a minute; retrying the same command shortly should work. " +
+    "Re-running the same command is usually enough.";
+/** The discriminator threshold: a signature failure whose wrap attempt
+ * took at least this many ms classifies as a load timeout; faster ones
+ * are genuine misses. The two causes are ~4ms (a real `which` "no") vs
+ * ~1000ms (srt's hard timeout) apart, so the midpoint has wide margins
+ * on both sides. Extracted per the coupled-rollout rule — the riskiest
+ * heuristic of the feature must be independently revertible. */
+export const SHELL_RESOLUTION_TRANSIENT_MIN_ELAPSED_MS = 500;
+/** Ladder backoffs between attempts after the first (2s/4s/8s/16s → 5
+ * attempts, ~30s of sleep + ~1s per failing `which`: ~35s worst case).
+ * Sized from the recorded incidents: multi-failure bursts prove sick
+ * windows of 15–22s, so the ladder absorbs the observed majority; the
+ * long tail falls through to the honest message. */
+const SHELL_RESOLUTION_LADDER_BACKOFFS_MS = [2000, 4000, 8000, 16000];
+/** Legacy single-retry backoff (retryPolicy "single"). */
+const SHELL_RESOLUTION_RETRY_BACKOFF_MS = 2000;
+/** Test seam for the ladder backoffs: session-layer tests (composition,
+ * user_bash) drive the ladder without per-call opts, so they shrink the
+ * module-level default instead of sleeping real seconds. Module-scoped
+ * (never a globalThis key — a leaked value there would silently shrink the
+ * production backoffs); restore in the same describe that sets it.
+ * Deliberately SEPARATE from the single-policy seam below: the two
+ * policies must not share a test override (a leaked ladder shrink would
+ * silently shrink the bg path's backoff). */
+let shellRetryBackoffsForTest = null;
+export function _setShellResolutionRetryBackoffsForTest(ms) {
+    shellRetryBackoffsForTest = ms;
+}
+function ladderBackoffs() {
+    return shellRetryBackoffsForTest ?? SHELL_RESOLUTION_LADDER_BACKOFFS_MS;
+}
+/** Test seam for the single-policy backoff (its own override — never the
+ * ladder's). Same module-scoped discipline. */
+let shellRetrySingleBackoffMsForTest = null;
+export function _setShellResolutionSingleRetryBackoffForTest(ms) {
+    shellRetrySingleBackoffMsForTest = ms;
+}
+/** Test seam for the discriminator threshold (session tests shrink it so
+ * their fakes need no real 600ms sleeps). Same module-scoped discipline. */
+let shellTransientMinElapsedMsForTest = null;
+export function _setShellResolutionTransientMinElapsedForTest(ms) {
+    shellTransientMinElapsedMsForTest = ms;
+}
+/** The candidate filenames `existsSync` should probe for `bin` on this
+ * platform: the bare name on POSIX, or each PATHEXT extension on Windows
+ * (the same names `where` would consider). */
+function pathCandidates(bin) {
+    if (process.platform === "win32") {
+        const exts = (process.env.PATHEXT ?? ".EXE").split(";");
+        return exts.map((e) => bin + (e.startsWith(".") ? e : "." + e));
+    }
+    return [bin];
+}
+/** Is the binary findable in the current PATH? An in-process scan (the same
+ * insight as the whole fix: answer a filesystem question with a filesystem
+ * check, never a subprocess) — and the SAME PATH srt's own `whichSync` sees:
+ * its spawnSync inherits this process's env, and the shell resolution runs
+ * in the host before the sandbox child ever starts. LOOSE by design:
+ * existence only, no X_OK — a false positive (found but not executable)
+ * errs toward the ladder, i.e. toward retrying, the safe side. For bare
+ * names the scan is an approximation of `which` (simple joins, no PATH
+ * semantics beyond the separator), so a "no" is strong but not absolute —
+ * a genuinely-broken exotic PATH shape could false-negative and surface
+ * the original error without retrying, the same posture as the fast-fail
+ * branch. */
+function foundOnPath(bin) {
+    if (bin.includes("/") || isAbsolute(bin))
+        return existsSync(bin);
+    const sep = process.platform === "win32" ? ";" : ":";
+    const dirs = (process.env.PATH ?? "").split(sep).filter(Boolean);
+    return dirs.some((dir) => pathCandidates(bin).some((name) => existsSync(join(dir, name))));
+}
 export async function preWrappedCommand(manager, command, binShell, opts = {}) {
     if (!manager.initialized)
         return command;
-    try {
-        return await manager.wrapWithSandbox(command, binShell);
-    }
-    catch (err) {
-        if (!isShellResolutionFailure(err))
-            throw err;
-    }
-    // The failed attempt may have left per-command state behind (the wrap can
-    // start helpers before it throws); clear it so the retry starts clean and
-    // the exec path's cleanupAfterCommand never sees double state. Best-effort:
-    // a cleanup throw must never swallow the original error or kill the retry.
-    try {
-        manager.cleanupAfterCommand();
-    }
-    catch (err) {
-        // Best-effort cleanup failed — the retry still runs (the exec path
-        // cleans up again); a fully silent swallow would hide a leaked-helper
-        // state, so the failure gets a visible trail. The message rides the
-        // line (the error class alone is always the literal "Error" for plain
-        // throws) and is run through scrubSecrets at WRITE time so the line
-        // is credential-scrubbed before any reader. That is pattern-scrub
-        // only, not a general redactor — readSessionTrail adds the same
-        // pattern pass at read time; the durable errors-*.jsonl stays
-        // unredacted by the sink's documented design (local file, never
-        // uploaded raw). Same posture as sandbox_persist_failed.
-        logEvent({
-            source: "sandbox",
-            level: "warn",
-            event: "shell_retry_cleanup_failed",
-            fields: {
-                error: scrubSecrets(err instanceof Error ? `${err.constructor.name}: ${err.message}` : String(err)),
-            },
+    const transientMinElapsedMs = opts.transientMinElapsedMs ?? shellTransientMinElapsedMsForTest ?? SHELL_RESOLUTION_TRANSIENT_MIN_ELAPSED_MS;
+    /** Corroboration: can this shell failure be a REAL miss? An absolute or
+     * path-bearing binShell that does not exist, or a bare name nowhere on
+     * PATH, is a true "no" regardless of machine load — never the ladder,
+     * never the honest-transient message. */
+    const provablyAbsent = () => typeof binShell === "string" && binShell.length > 0 && !foundOnPath(binShell);
+    const isGenuineMiss = (elapsedMs) => provablyAbsent() || elapsedMs < transientMinElapsedMs;
+    const attempt = () => {
+        const startedAt = Date.now();
+        return manager.wrapWithSandbox(command, binShell).then((wrapped) => ({ wrapped, elapsedMs: Date.now() - startedAt }), (err) => ({ err, elapsedMs: Date.now() - startedAt }));
+    };
+    // Best-effort cleanup between attempts: the failed wrap may have left
+    // per-command state behind (it can start helpers before it throws); clear
+    // it so the retry starts clean and the exec path's cleanupAfterCommand
+    // never sees double state. A cleanup throw must never swallow the
+    // original error or kill the retry; a fully silent swallow would hide a
+    // leaked-helper state, so the failure gets a visible trail. The message
+    // rides the line (the error class alone is always the literal "Error" for
+    // plain throws) and is run through scrubSecrets at WRITE time so the line
+    // is credential-scrubbed before any reader. That is pattern-scrub only,
+    // not a general redactor — readSessionTrail adds the same pattern pass at
+    // read time; the durable errors-*.jsonl stays unredacted by the sink's
+    // documented design (local file, never uploaded raw). Same posture as
+    // sandbox_persist_failed.
+    const cleanup = () => {
+        try {
+            manager.cleanupAfterCommand();
+        }
+        catch (err) {
+            logEvent({
+                source: "sandbox",
+                level: "warn",
+                event: "shell_retry_cleanup_failed",
+                fields: {
+                    error: scrubSecrets(err instanceof Error ? `${err.constructor.name}: ${err.message}` : String(err)),
+                },
+            });
+        }
+    };
+    const first = await attempt();
+    if (first.wrapped !== undefined)
+        return first.wrapped;
+    if (!isShellResolutionFailure(first.err))
+        throw first.err;
+    if (isGenuineMiss(first.elapsedMs)) {
+        logShellResolutionClassification({
+            classification: "genuine-miss",
+            elapsedMs: first.elapsedMs,
+            absoluteShell: typeof binShell === "string" && isAbsolute(binShell),
+            provablyAbsent: provablyAbsent(),
         });
+        throw first.err;
     }
-    await sleep(effectiveBackoffMs(opts.backoffMs), opts.signal);
-    try {
-        const wrapped = await manager.wrapWithSandbox(command, binShell);
-        opts.onRetry?.("recovered");
-        return wrapped;
+    cleanup();
+    const backoffs = opts.retryPolicy === "single"
+        ? [shellRetrySingleBackoffMsForTest ?? SHELL_RESOLUTION_RETRY_BACKOFF_MS]
+        : ladderBackoffs();
+    let lastErr = first.err;
+    let lastWasSignature = true;
+    for (const backoffMs of backoffs) {
+        await sleep(backoffMs, opts.signal);
+        const next = await attempt();
+        if (next.wrapped !== undefined) {
+            opts.onRetry?.("recovered");
+            return next.wrapped;
+        }
+        if (!isShellResolutionFailure(next.err)) {
+            // An unrelated mid-ladder error propagates as-is and does NOT fire
+            // `exhausted` — the health signal stays clean (only the terminal
+            // same-signature failure reports exhausted). The failed attempt
+            // still gets its cleanup (uniform with every other failed attempt).
+            cleanup();
+            lastErr = next.err;
+            lastWasSignature = false;
+            break;
+        }
+        lastErr = next.err;
+        lastWasSignature = true;
+        cleanup();
     }
-    catch (err) {
-        // `exhausted` is the shell-resolution health signal — report it only
-        // when the second failure is the SAME transient; an unrelated retry
-        // error propagates as-is without polluting the metric.
-        if (isShellResolutionFailure(err))
-            opts.onRetry?.("exhausted");
-        throw err;
+    if (lastWasSignature) {
+        opts.onRetry?.("exhausted");
+        // The honest message replaces the lie on the discriminated-timeout
+        // path only; a genuine miss (surfaced above) keeps the original —
+        // there the "not found in PATH" text is accurate. The ORIGINAL error
+        // rides as `cause` so the terminal classification (shell name,
+        // signature) survives for diagnostics from the thrown value alone.
+        throw new Error(SHELL_RESOLUTION_TRANSIENT_MESSAGE, { cause: lastErr });
     }
+    throw lastErr;
 }
-/** Default backoff before the single shell-resolution retry. The observed
- * upstream transient self-heals in ~15–30s; this is a bounded bridge, not
- * a guarantee — a still-failing second attempt surfaces the original error. */
-const SHELL_RESOLUTION_RETRY_BACKOFF_MS = 2000;
-/** Test seam for the backoff: session-layer tests (composition, user_bash)
- * drive the retry without a backoffMs opt, so they shrink the module-level
- * default instead of sleeping a real 2s. Module-scoped (never a globalThis
- * key — a leaked value there would silently shrink the production backoff);
- * restore in the same describe that sets it. */
-let shellRetryBackoffMsForTest = null;
-export function _setShellResolutionRetryBackoffForTest(ms) {
-    shellRetryBackoffMsForTest = ms;
-}
-function effectiveBackoffMs(override) {
-    return override ?? shellRetryBackoffMsForTest ?? SHELL_RESOLUTION_RETRY_BACKOFF_MS;
+/** Sink line for the discriminator's classification — the auditability of
+ * the 500ms threshold: a mis-tuned threshold would otherwise look like "no
+ * retries happened" in prod. Fires only on the GENUINE-MISS classification
+ * (the rare path — one line per surfaced config problem); the load-timeout
+ * path is already counted by shell_resolution_retry's recovered/exhausted
+ * census. Closed-enum classification + elapsed ms + the corroboration
+ * booleans: no command or shell content. */
+function logShellResolutionClassification(fields) {
+    logEvent({
+        source: "sandbox",
+        level: "info",
+        event: "shell_resolution_genuine_miss",
+        fields,
+    });
 }
 function sleep(ms, signal) {
     // The abort rejection carries the caller's own abort reason when the
@@ -219,10 +339,11 @@ function sleep(ms, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-/** srt's transient shell-resolution failure: `Shell '<name>' not found in
- * PATH`, thrown from wrapCommandWithSandbox when which.js's 1s
- * spawnSync('which') times out under load. Self-healing after ~15–30s;
- * preWrappedCommand retries it once. */
+/** srt's shell-resolution failure: `Shell '<name>' not found in PATH`,
+ * thrown from wrapCommandWithSandbox when which.js's 1s spawnSync('which')
+ * times out under load — or genuinely answers "no". preWrappedCommand
+ * splits the two by evidence (see its doc) and retries only the load
+ * timeout, on an exponential ladder. */
 export function isShellResolutionFailure(err) {
     return err instanceof Error && /^Shell '[^']*' not found in PATH$/.test(err.message);
 }

package/dist/extension/sandbox/session.js

@@ -161,9 +161,14 @@ export function makeBashComposition(manager, settings, cwd, onShellResolutionRet
                     let bgCommand = input.command;
                     let bgEnv;
                     if (useSandbox) {
+                        // retryPolicy "single": the bg launch ack is returns-
+                        // immediately, and bg launches are precisely the high-load
+                        // moments — a silent 35s ladder stall on the ack is worse than
+                        // the error, so the legacy one-quick-retry stands here.
                         bgCommand = await preWrappedCommand(manager, input.command, binShell, {
                             signal: signal ?? undefined,
                             onRetry: onShellResolutionRetry,
+                            retryPolicy: "single",
                         });
                         bgEnv = { ...process.env, ...sandboxSpawnEnv(manager) };
                         manager.cleanupAfterCommand();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.6-staging.1438.1",
+  "version": "1.1.6-staging.1443.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "273d4311096e1a2eec5f56baaa6e267817a2011e"
+  "yagniSourceSha": "8e549e888319699160837efefdfa8f1d835a84b5"
 }