@rallycry/conveyor-agent 10.13.13 → 10.13.14

package/dist/{chunk-TB5SQIGX.js → chunk-J4UH5TOO.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7TQO4ZF4.js";
 import {
   getWorkbenchClient
-} from "./chunk-YRC57EYG.js";
+} from "./chunk-LZM5OKAC.js";
 import {
   workbenchEnabled
 } from "./chunk-4VUQ2NPF.js";
@@ -11,8 +11,6 @@ import {
   MAX_BETWEEN_TURN_BUFFER,
   MAX_DIAGNOSTIC_OUTPUT,
   buildPromptBytes,
-  buildSnapshotTar,
-  extractSnapshotTar,
   inheritedEnv,
   loadPtySpawn,
   parseUserQuestions,
@@ -25,7 +23,7 @@ import {
   sleep,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-2K6RRTQC.js";
+} from "./chunk-RSIW2UCR.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -207,7 +205,6 @@ var AgentConnection = class _AgentConnection {
   modeChangeCallback = null;
   apiKeyUpdateCallback = null;
   pullBranchCallback = null;
-  finalizeSnapshotCallback = null;
   runStartCommandCallback = null;
   earlyPullBranches = [];
   spawnReviewCallback = null;
@@ -431,9 +428,6 @@ var AgentConnection = class _AgentConnection {
         if (this.probeUsageCallback) this.probeUsageCallback();
         else this.earlyProbeUsage = true;
       });
-      this.socket.on("session:finalizeSnapshot", () => {
-        this.finalizeSnapshotCallback?.();
-      });
       this.socket.on("session:runStartCommand", () => {
         this.runStartCommandCallback?.();
       });
@@ -714,9 +708,6 @@ var AgentConnection = class _AgentConnection {
     }).catch(() => {
     });
   }
-  onFinalizeSnapshot(callback) {
-    this.finalizeSnapshotCallback = callback;
-  }
   onRunStartCommand(callback) {
     this.runStartCommandCallback = callback;
   }
@@ -1226,55 +1217,51 @@ async function git(cwd, args, timeoutMs = GIT_TIMEOUT_MS) {
   });
   return stdout.toString().trim();
 }
-async function syncWithBaseBranch(cwd, baseBranch) {
-  if (!baseBranch) return true;
+async function ensureOnTaskBranch(cwd, taskBranch, baseBranch) {
+  if (!taskBranch) return true;
   try {
-    await git(cwd, ["fetch", "origin", baseBranch]);
-  } catch {
-    process.stderr.write(
-      `[conveyor-agent] Warning: git fetch origin ${baseBranch} failed, continuing with current base
+    if (await getCurrentBranch(cwd) === taskBranch) return true;
+    let existsOnOrigin = true;
+    try {
+      await git(cwd, [
+        "fetch",
+        "origin",
+        `+refs/heads/${taskBranch}:refs/remotes/origin/${taskBranch}`
+      ]);
+    } catch (err) {
+      if (String(err).includes("couldn't find remote ref")) existsOnOrigin = false;
+      else throw err;
+    }
+    if (existsOnOrigin) {
+      await git(cwd, ["checkout", "-B", taskBranch, `origin/${taskBranch}`], 3e4);
+      process.stderr.write(`[conveyor-agent] Checked out task branch ${taskBranch}
+`);
+      return true;
+    }
+    if (!baseBranch) {
+      process.stderr.write(
+        `[conveyor-agent] Warning: task branch ${taskBranch} missing on origin and no base branch given
 `
-    );
-    return false;
-  }
-  try {
-    await git(cwd, ["merge", `origin/${baseBranch}`, "--no-edit"], 3e4);
-  } catch {
+      );
+      return false;
+    }
+    await git(cwd, [
+      "fetch",
+      "origin",
+      `+refs/heads/${baseBranch}:refs/remotes/origin/${baseBranch}`
+    ]);
+    await git(cwd, ["checkout", "-B", taskBranch, `origin/${baseBranch}`], 3e4);
+    await git(cwd, ["push", "-u", "origin", taskBranch], 3e4);
     process.stderr.write(
-      `[conveyor-agent] Warning: merge origin/${baseBranch} failed, aborting merge and continuing
+      `[conveyor-agent] Created task branch ${taskBranch} from origin/${baseBranch} and pushed
 `
     );
-    try {
-      await git(cwd, ["merge", "--abort"], 3e4);
-    } catch {
-    }
-    return false;
-  }
-  process.stderr.write(`[conveyor-agent] Synced with latest origin/${baseBranch}
-`);
-  return true;
-}
-async function ensureOnTaskBranch(cwd, taskBranch) {
-  if (!taskBranch) return true;
-  const current = await getCurrentBranch(cwd);
-  if (current === taskBranch) return true;
-  try {
-    await git(cwd, ["fetch", "origin", taskBranch]);
-  } catch {
-    process.stderr.write(`[conveyor-agent] Warning: git fetch origin ${taskBranch} failed
-`);
-    return false;
-  }
-  try {
-    await git(cwd, ["checkout", "-B", taskBranch, `origin/${taskBranch}`], 3e4);
+    return true;
   } catch {
-    process.stderr.write(`[conveyor-agent] Warning: git checkout ${taskBranch} failed
+    process.stderr.write(`[conveyor-agent] Warning: ensureOnTaskBranch(${taskBranch}) failed
 `);
     return false;
   }
-  process.stderr.write(`[conveyor-agent] Checked out task branch ${taskBranch}
-`);
-  return true;
 }
 async function hasUncommittedChanges(cwd) {
   const status = await git(cwd, ["status", "--porcelain"], GIT_SLOW_TIMEOUT_MS);
@@ -1599,206 +1586,6 @@ async function backupOtherBranches(cwd, currentBranch) {
   return count;
 }
 
-// src/runner/work-preservation/index.ts
-import { mkdtemp, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join } from "path";
-
-// src/runner/work-preservation/restore-precedence.ts
-function selectRestoreSource(probe) {
-  if (probe.gcsAvailable) return "gcs";
-  if (probe.wipRestoreResult === "applied") return "wip";
-  return "clean";
-}
-
-// src/runner/work-preservation/snapshot-transfer.ts
-import { randomUUID } from "crypto";
-import { createReadStream, createWriteStream } from "fs";
-import { rm } from "fs/promises";
-import { tmpdir } from "os";
-import path from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-var SNAPSHOT_HTTP_TIMEOUT_MS = 6e4;
-var SNAPSHOT_CAPTURED_AT_HEADER = "x-snapshot-captured-at";
-async function putSnapshotToGcs(url, tarResult) {
-  try {
-    const body = Readable.toWeb(createReadStream(tarResult.tarPath));
-    const res = await fetch(url, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/gzip",
-        "Content-Length": String(tarResult.sizeBytes),
-        [SNAPSHOT_CAPTURED_AT_HEADER]: String(tarResult.capturedAt)
-      },
-      body,
-      duplex: "half",
-      signal: AbortSignal.timeout(SNAPSHOT_HTTP_TIMEOUT_MS)
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-async function downloadSnapshotToTemp(url) {
-  const tmpTar = path.join(tmpdir(), `conveyor-snapshot-restore-${randomUUID()}.tar.gz`);
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      signal: AbortSignal.timeout(SNAPSHOT_HTTP_TIMEOUT_MS)
-    });
-    if (!res.ok || !res.body) return null;
-    await pipeline(
-      Readable.fromWeb(res.body),
-      createWriteStream(tmpTar)
-    );
-    return tmpTar;
-  } catch {
-    await rm(tmpTar, { force: true }).catch(() => {
-    });
-    return null;
-  }
-}
-
-// src/runner/work-preservation/index.ts
-async function captureSnapshotTar(cwd) {
-  if (!workbenchEnabled()) return buildSnapshotTar(cwd);
-  const staging = await mkdtemp(join(tmpdir2(), "conveyor-snapshot-remote-"));
-  const cleanup = async () => {
-    await rm2(staging, { recursive: true, force: true }).catch(() => {
-    });
-  };
-  try {
-    const meta = await getWorkbenchClient().buildSnapshot(cwd, join(staging, "snapshot.tar.gz"));
-    return {
-      tarPath: meta.tarPath,
-      sizeBytes: meta.sizeBytes,
-      fileCount: meta.fileCount,
-      deletionCount: meta.deletionCount,
-      capturedAt: meta.capturedAt,
-      cleanup
-    };
-  } catch (err) {
-    await cleanup();
-    throw err;
-  }
-}
-function applySnapshotTar(cwd, tarPath) {
-  return workbenchEnabled() ? getWorkbenchClient().extractSnapshot(cwd, tarPath) : extractSnapshotTar(cwd, tarPath);
-}
-var periodicTimer = null;
-var inFlightCapture = null;
-var inFlightGcsUpload = null;
-var EMPTY_GCS_RESULT = {
-  uploaded: false,
-  fileCount: 0,
-  deletionCount: 0,
-  sizeBytes: 0
-};
-async function doUploadSnapshotToGcs(cwd, uploadUrl, opts) {
-  let tarResult;
-  try {
-    tarResult = await captureSnapshotTar(cwd);
-  } catch {
-    return EMPTY_GCS_RESULT;
-  }
-  try {
-    const uploaded = (opts?.forceUpload || tarResult.sizeBytes > 0) && uploadUrl ? await putSnapshotToGcs(uploadUrl, tarResult) : false;
-    return {
-      uploaded,
-      fileCount: tarResult.fileCount,
-      deletionCount: tarResult.deletionCount,
-      sizeBytes: tarResult.sizeBytes
-    };
-  } finally {
-    await tarResult.cleanup();
-  }
-}
-async function uploadSnapshotToGcs(cwd, uploadUrl, opts) {
-  const previous = inFlightGcsUpload;
-  const run = (async () => {
-    if (previous) await previous.catch(() => {
-    });
-    return doUploadSnapshotToGcs(cwd, uploadUrl, opts);
-  })();
-  inFlightGcsUpload = run;
-  try {
-    return await run;
-  } finally {
-    if (inFlightGcsUpload === run) inFlightGcsUpload = null;
-  }
-}
-async function captureSnapshot(ctx) {
-  const gcs = await uploadSnapshotToGcs(ctx.cwd, ctx.snapshotUploadUrl, {
-    forceUpload: ctx.forceUpload
-  });
-  const wipResult = await flushPendingChanges(ctx.cwd, {
-    wipMessage: ctx.wipMessage ?? "WIP: WorkPreservation periodic snapshot",
-    refreshToken: ctx.refreshToken
-  });
-  return {
-    fileCount: gcs.fileCount,
-    deletionCount: gcs.deletionCount,
-    sizeBytes: gcs.sizeBytes,
-    gcsUploaded: gcs.uploaded,
-    wipPushed: wipResult.committed || wipResult.pushed
-  };
-}
-function startPeriodic(intervalMs, ctx) {
-  stop();
-  periodicTimer = setInterval(() => {
-    if (inFlightCapture) return;
-    const run = captureSnapshot(ctx);
-    inFlightCapture = run;
-    void run.catch(() => {
-    }).finally(() => {
-      if (inFlightCapture === run) inFlightCapture = null;
-    });
-  }, intervalMs);
-}
-function stop() {
-  if (periodicTimer) {
-    clearInterval(periodicTimer);
-    periodicTimer = null;
-  }
-}
-async function finalizeForSleep(ctx) {
-  stop();
-  if (inFlightCapture) await inFlightCapture.catch(() => {
-  });
-  return captureSnapshot({
-    ...ctx,
-    wipMessage: ctx.wipMessage ?? "WIP: WorkPreservation sleep finalize snapshot",
-    // Always stamp snapshotAt on sleep — even an empty workspace must confirm
-    // the finalize so teardown doesn't wait out the reconciler's cap.
-    forceUpload: true
-  });
-}
-async function restoreOnBoot(bundle, cwd) {
-  let gcsAvailable = false;
-  let gcsFileCount;
-  if (bundle.snapshotUrl) {
-    const tmpTar = await downloadSnapshotToTemp(bundle.snapshotUrl);
-    if (tmpTar) {
-      try {
-        const result = await applySnapshotTar(cwd, tmpTar);
-        if (result.status === "extracted") {
-          gcsAvailable = true;
-          gcsFileCount = result.filesExtracted;
-        }
-      } catch {
-        gcsAvailable = false;
-      } finally {
-        await rm2(tmpTar, { force: true }).catch(() => {
-        });
-      }
-    }
-  }
-  const wipRestoreResult = gcsAvailable ? "none" : await restoreWipSnapshot(cwd, bundle.gitPlan.branch);
-  const source = selectRestoreSource({ gcsAvailable, wipRestoreResult });
-  return source === "gcs" ? { source, fileCount: gcsFileCount } : { source };
-}
-
 // ../shared/dist/index.js
 import { z } from "zod";
 import { z as z2 } from "zod";
@@ -3306,9 +3093,9 @@ var ClaudeCodeHarness = class {
 };
 
 // src/harness/pty/session.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { mkdtemp as mkdtemp2, mkdir as mkdir3, rm as rm4 } from "fs/promises";
-import { join as join5, dirname } from "path";
+import { randomUUID } from "crypto";
+import { mkdtemp, mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import { join as join4, dirname } from "path";
 
 // src/harness/pty/event-queue.ts
 var AsyncEventQueue = class {
@@ -3589,8 +3376,8 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path3, onEvent, onRawRecord) {
-    this.path = path3;
+  constructor(path2, onEvent, onRawRecord) {
+    this.path = path2;
     this.onEvent = onEvent;
     this.onRawRecord = onRawRecord;
   }
@@ -3852,15 +3639,15 @@ function mapChatRecords(raw) {
 // src/harness/pty/settings.ts
 import { mkdir, writeFile, chmod } from "fs/promises";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join } from "path";
 function claudeConfigHome() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join2(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
 }
 function projectSlug(cwd) {
   return cwd.replace(/\//g, "-");
 }
 function sessionTranscriptPath(cwd, sessionId) {
-  return join2(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
+  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
 }
 var ALLOW_RULES = [
   "Bash",
@@ -4028,8 +3815,8 @@ function preToolUse(payload) {
 }
 `;
 async function writeHookSettings(dir) {
-  const helperPath = join2(dir, "hook-helper.cjs");
-  const settingsPath = join2(dir, "settings.json");
+  const helperPath = join(dir, "hook-helper.cjs");
+  const settingsPath = join(dir, "settings.json");
   await mkdir(dir, { recursive: true });
   await writeFile(helperPath, HOOK_HELPER_SOURCE, "utf8");
   await chmod(helperPath, 493);
@@ -4147,7 +3934,7 @@ var PtyOutputCoalescer = class {
 import { createServer as createServer2 } from "http";
 import { z as z6 } from "zod";
 import { writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -4338,7 +4125,7 @@ async function startToolServers(mcpServers, tempDir) {
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
   if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
-  const mcpConfigPath = join3(tempDir, "mcp-config.json");
+  const mcpConfigPath = join2(tempDir, "mcp-config.json");
   await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
   return { servers, mcpConfigPath };
 }
@@ -4414,13 +4201,13 @@ ${tail}`);
 }
 
 // src/harness/pty/credentials.ts
-import { chmod as chmod2, mkdir as mkdir2, readFile, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile, rm, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
 var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
 function claudeCredentialsPath() {
-  return join4(claudeConfigHome(), ".credentials.json");
+  return join3(claudeConfigHome(), ".credentials.json");
 }
 function isConveyorCloudEnv(env = process.env) {
   return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
@@ -4465,9 +4252,9 @@ function planCredentialsWrite(input) {
   if (fresh) return { action: "skip", reason: "current" };
   return { action: "write", contents };
 }
-async function readRaw(path3) {
+async function readRaw(path2) {
   try {
-    return await readFile(path3, "utf8");
+    return await readFile(path2, "utf8");
   } catch {
     return null;
   }
@@ -4509,10 +4296,10 @@ async function writeWithReadBackRetry(io2, contents, delaysMs = READ_BACK_DELAYS
     await sleep2(delaysMs[attempt]);
   }
 }
-function fsWriteIo(path3, mode) {
+function fsWriteIo(path2, mode) {
   return {
-    write: (contents) => writeFile3(path3, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
-    read: () => readRaw(path3)
+    write: (contents) => writeFile3(path2, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
+    read: () => readRaw(path2)
   };
 }
 async function ensureClaudeCredentials(env = process.env) {
@@ -4522,23 +4309,23 @@ async function ensureClaudeCredentials(env = process.env) {
     await sanitizeApprovedApiKeys(token);
   }
   try {
-    const path3 = claudeCredentialsPath();
+    const path2 = claudeCredentialsPath();
     const plan = planCredentialsWrite({
       isCloud,
       token,
-      existingRaw: await readRaw(path3),
+      existingRaw: await readRaw(path2),
       now: Date.now()
     });
     if (plan.action === "skip") return;
     await mkdir2(claudeConfigHome(), { recursive: true });
-    const verified = await writeWithReadBackRetry(fsWriteIo(path3, 384), plan.contents);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path2, 384), plan.contents);
     if (!verified) {
       process.stderr.write(
-        `[conveyor-agent] claude credentials read-back still stale after retries at ${path3} \u2014 TUI may land on the login picker
+        `[conveyor-agent] claude credentials read-back still stale after retries at ${path2} \u2014 TUI may land on the login picker
 `
       );
     }
-    await chmod2(path3, 384).catch(() => {
+    await chmod2(path2, 384).catch(() => {
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -4567,12 +4354,12 @@ function planApprovedApiKeyCleanup(existingRaw, oauthToken) {
 }
 async function sanitizeApprovedApiKeys(oauthToken) {
   try {
-    const path3 = claudeJsonPath();
-    const cleaned = planApprovedApiKeyCleanup(await readRaw(path3), oauthToken);
+    const path2 = claudeJsonPath();
+    const cleaned = planApprovedApiKeyCleanup(await readRaw(path2), oauthToken);
     if (cleaned === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path3), cleaned);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path2), cleaned);
     process.stderr.write(
-      verified ? "[conveyor-agent] removed poisoned customApiKeyResponses.approved entry from .claude.json\n" : `[conveyor-agent] approved-key sanitize read-back still stale after retries at ${path3} \u2014 CLI may still see the poisoned entry
+      verified ? "[conveyor-agent] removed poisoned customApiKeyResponses.approved entry from .claude.json\n" : `[conveyor-agent] approved-key sanitize read-back still stale after retries at ${path2} \u2014 CLI may still see the poisoned entry
 `
     );
   } catch (err) {
@@ -4583,7 +4370,7 @@ async function sanitizeApprovedApiKeys(oauthToken) {
 }
 function claudeJsonPath() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join4(configDir, ".claude.json") : join4(homedir2(), ".claude.json");
+  return configDir ? join3(configDir, ".claude.json") : join3(homedir2(), ".claude.json");
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -4676,7 +4463,7 @@ function planClaudeJsonSeed(existingRaw, trustCwd, oauthIdentity) {
   return changed ? JSON.stringify(config) : null;
 }
 function conveyorOauthMarkerPath() {
-  return join4(claudeConfigHome(), "conveyor-oauth-account.json");
+  return join3(claudeConfigHome(), "conveyor-oauth-account.json");
 }
 function parseOauthIdentity(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -4709,8 +4496,8 @@ async function persistOauthIdentityMarker(configIdentity, markerIdentity) {
 async function ensureClaudeOnboarding(env = process.env, trustCwd) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path3 = claudeJsonPath();
-    const existingRaw = await readRaw(path3);
+    const path2 = claudeJsonPath();
+    const existingRaw = await readRaw(path2);
     const markerIdentity = parseOauthIdentity(await readRaw(conveyorOauthMarkerPath()));
     await persistOauthIdentityMarker(
       extractOauthIdentity(parseClaudeJson(existingRaw)),
@@ -4718,16 +4505,16 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
     );
     const contents = planClaudeJsonSeed(existingRaw, trustCwd, markerIdentity);
     if (contents === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path3), contents);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path2), contents);
     if (verified) {
       process.stderr.write(
         `[conveyor-agent] claude onboarding seeded${trustCwd ? ` (trust: ${trustCwd})` : ""}
 `
       );
     } else {
-      const verify = await readRaw(path3);
+      const verify = await readRaw(path2);
       process.stderr.write(
-        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path3} after retries: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
+        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path2} after retries: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
 `
       );
     }
@@ -4740,12 +4527,12 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
 async function removeConveyorCredentials(env = process.env) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path3 = claudeCredentialsPath();
-    const existing = parseClaudeAiOauth(await readRaw(path3));
+    const path2 = claudeCredentialsPath();
+    const existing = parseClaudeAiOauth(await readRaw(path2));
     if (existing && typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
       return;
     }
-    await rm3(path3, { force: true });
+    await rm(path2, { force: true });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[conveyor-agent] claude credentials removal failed: ${message}
@@ -5053,7 +4840,7 @@ var PtySession = class {
         const { settingsPath, socketPath } = await this.startStructuredEventSources(sessionId);
         await this.spawn(settingsPath, socketPath);
       } else {
-        this.tempDir = await mkdtemp2(join5(sessionTempBase(), "conveyor-pty-"));
+        this.tempDir = await mkdtemp(join4(sessionTempBase(), "conveyor-pty-"));
         await this.spawn();
         this.pushEvent({
           type: "system",
@@ -5090,8 +4877,8 @@ var PtySession = class {
    * paths spawn() must wire into the child's argv/env.
    */
   async startStructuredEventSources(sessionId) {
-    this.tempDir = await mkdtemp2(join5(sessionTempBase(), "conveyor-pty-"));
-    const socketPath = join5(this.tempDir, "hook.sock");
+    this.tempDir = await mkdtemp(join4(sessionTempBase(), "conveyor-pty-"));
+    const socketPath = join4(this.tempDir, "hook.sock");
     this.socket = new HookSocketServer(
       socketPath,
       (progress) => this.handleProgress(progress),
@@ -5145,7 +4932,7 @@ var PtySession = class {
    * questionnaire resolves; see the field comment). */
   emitSyntheticQuestionCard(questions) {
     if (questions.length === 0 || typeof this.bridge?.sendChatEvent !== "function") return;
-    const id = `aq-${randomUUID2()}`;
+    const id = `aq-${randomUUID()}`;
     this.pendingSyntheticQuestionIds.push(id);
     this.sendChatEvent({
       kind: "tool_use",
@@ -5268,7 +5055,7 @@ var PtySession = class {
     this.activeQueue?.close();
     this.activeQueue = null;
     if (this.tempDir) {
-      await rm4(this.tempDir, { recursive: true, force: true });
+      await rm2(this.tempDir, { recursive: true, force: true });
       this.tempDir = "";
     }
   }
@@ -5544,7 +5331,7 @@ var PtySession = class {
 // src/harness/pty/config-home-health.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var MOUNT_DISCONNECT_CODES = /* @__PURE__ */ new Set(["ENOTCONN", "EIO", "ESTALE", "ENXIO"]);
 var MOUNT_DISCONNECT_MESSAGES = [
   "socket is not connected",
@@ -5560,12 +5347,12 @@ function isMountDisconnectError(err) {
   return MOUNT_DISCONNECT_MESSAGES.some((needle) => lower.includes(needle));
 }
 function podLocalConfigHome() {
-  return join6(homedir3(), ".claude-local");
+  return join5(homedir3(), ".claude-local");
 }
 async function ensureUsableClaudeConfigHome(cwd, log) {
   const configHome = claudeConfigHome();
   try {
-    await mkdir4(join6(configHome, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join5(configHome, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome, fellBack: false };
   } catch (err) {
     if (!isMountDisconnectError(err)) throw err;
@@ -5579,7 +5366,7 @@ async function ensureUsableClaudeConfigHome(cwd, log) {
       }
     );
     process.env.CLAUDE_CONFIG_DIR = fallback;
-    await mkdir4(join6(fallback, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join5(fallback, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome: fallback, fellBack: true };
   }
 }
@@ -6066,20 +5853,20 @@ function formatIncidents(incidents) {
 
 // src/workbench/fs.ts
 import { readFile as localReadFile, readdir as localReaddir, stat as localStat } from "fs/promises";
-async function readWorkspaceFile(path3) {
+async function readWorkspaceFile(path2) {
   if (workbenchEnabled()) {
-    return (await getWorkbenchClient().readFile(path3)).toString("utf8");
+    return (await getWorkbenchClient().readFile(path2)).toString("utf8");
   }
-  return localReadFile(path3, "utf-8");
+  return localReadFile(path2, "utf-8");
 }
-function readWorkspaceDir(path3) {
-  if (workbenchEnabled()) return getWorkbenchClient().readdir(path3);
-  return localReaddir(path3);
+function readWorkspaceDir(path2) {
+  if (workbenchEnabled()) return getWorkbenchClient().readdir(path2);
+  return localReaddir(path2);
 }
-async function statWorkspacePath(path3) {
-  if (workbenchEnabled()) return getWorkbenchClient().stat(path3);
+async function statWorkspacePath(path2) {
+  if (workbenchEnabled()) return getWorkbenchClient().stat(path2);
   try {
-    const s = await localStat(path3);
+    const s = await localStat(path2);
     return {
       exists: true,
       isFile: s.isFile(),
@@ -6091,8 +5878,8 @@ async function statWorkspacePath(path3) {
     return { exists: false, isFile: false, isDirectory: false, size: 0, mtimeMs: 0 };
   }
 }
-async function workspacePathExists(path3) {
-  return (await statWorkspacePath(path3)).exists;
+async function workspacePathExists(path2) {
+  return (await statWorkspacePath(path2)).exists;
 }
 
 // src/execution/tag-context-resolver.ts
@@ -6463,13 +6250,15 @@ function buildPlanDocumentationSection(context) {
   const hasPlan = !!context?.plan?.trim();
   return [
     ``,
-    `### Plan & Properties (post the plan BEFORE building \u2014 no approval wait)`,
+    `### Plan first, then BUILD \u2014 the plan is a step, NOT the deliverable`,
     `- The card is already In Progress and advances automatically (In Progress \u2192 Review PR when you open the PR). There is no plan-approval step.`,
     ...hasPlan ? [
-      `- A plan is already saved on the card. Keep it current with update_task_plan if your approach diverges materially from it.`
+      `- A plan is already saved on the card. Keep it current with update_task_plan if your approach diverges materially \u2014 then IMPLEMENT it in code. The saved plan is not the deliverable; the working implementation is.`
     ] : [
-      `- No plan is saved yet: BEFORE writing any code, investigate briefly (search first, read only critical files) and save a concise implementation plan with update_task_plan (file:line citations). Then start implementing immediately \u2014 the plan is a record for the team, not a gate; never pause for approval.`
+      `- No plan is saved yet: BEFORE writing any code, investigate briefly (search first, read only critical files) and save a concise implementation plan with update_task_plan (file:line citations). Saving the plan is a planning step, not the goal \u2014 immediately move on to WRITING THE CODE that implements it; never pause for approval.`
     ],
+    `- Your goal is to BUILD the change, not to produce a plan. After the plan is posted, actually implement it: edit source files, make the change work, then verify. Do NOT stop, go idle, or open a PR the moment the plan exists.`,
+    `- Your pull request MUST contain the actual code implementation. Never open a plan-only or empty-diff PR \u2014 a PR that just records the plan is never the goal of auto mode unless the task explicitly asks ONLY for a plan. (If the task genuinely needs no code changes, don't open a PR at all \u2014 finish per the section below.)`,
     `- Identification auto-fills title, story points, and icon with quick AI guesses. After exploring, refine the title and story points with update_task_properties if they look like placeholders. Icons are automatic \u2014 never set them.`
   ];
 }
@@ -7115,7 +6904,7 @@ function buildFreshLeafInstructions(context, isAutoMode) {
     `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`
   ] : [
     `No plan is saved on this card yet. Investigate the task briefly (search first, read only critical files), then save a concise implementation plan with update_task_plan (file:line citations) BEFORE you start writing code.`,
-    `Once the plan is posted, implement it immediately \u2014 do NOT pause or wait for approval; the card is already In Progress and advances automatically.`,
+    `The plan is a step, not the goal: the moment it's posted, IMPLEMENT it in code \u2014 do NOT pause, wait for approval, or treat the posted plan as the deliverable. The card is already In Progress and advances automatically.`,
     `Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`
   ];
   parts.push(
@@ -7127,9 +6916,10 @@ function buildFreshLeafInstructions(context, isAutoMode) {
   if (isAutoMode) {
     parts.push(
       `
-CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
-      `Do NOT summarize the plan or say "ready to implement" \u2014 start implementing immediately.`,
-      `When all changes are ready, you MUST use mcp__conveyor__create_pull_request to open a PR before finishing.`,
+CRITICAL: You are in Auto mode. Your job is to BUILD the change, not to produce a plan \u2014 making a plan and opening a PR of the plan is NOT the goal. The plan is only an intermediate step; you must then write the code that implements it.`,
+      `Do NOT report status, ask for confirmation, or go idle without making code changes. Do NOT summarize the plan or say "ready to implement" \u2014 start implementing immediately.`,
+      `Your pull request MUST contain the actual code implementation. Never open a plan-only or empty-diff PR. (If the task genuinely needs no code changes, do not open a PR \u2014 deliver the result in chat and mark the card Complete.)`,
+      `When the implementation is complete and verified, you MUST use mcp__conveyor__create_pull_request to open a PR before finishing.`,
       `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
     );
   }
@@ -7868,7 +7658,7 @@ function buildMutationTools(connection, config) {
 
 // src/tools/attachment-tools.ts
 import { readFile as readFile2, stat } from "fs/promises";
-import { basename, extname, isAbsolute, join as join7 } from "path";
+import { basename, extname, isAbsolute, join as join6 } from "path";
 import { z as z10 } from "zod";
 var IMAGE_MIME_BY_EXT = {
   ".png": "image/png",
@@ -7885,9 +7675,9 @@ function buildUploadAttachmentTool(connection, config) {
       path: z10.string().describe("Path to the image file \u2014 absolute, or relative to the workspace root"),
       title: z10.string().optional().describe("Short caption posted with the image (defaults to the file name)")
     },
-    async ({ path: path3, title }) => {
+    async ({ path: path2, title }) => {
       try {
-        const filePath = isAbsolute(path3) ? path3 : join7(config.workspaceDir, path3);
+        const filePath = isAbsolute(path2) ? path2 : join6(config.workspaceDir, path2);
         const mimeType = IMAGE_MIME_BY_EXT[extname(filePath).toLowerCase()];
         if (!mimeType) {
           return textResult(
@@ -8649,7 +8439,7 @@ function createConveyorMcpServer(harness, connection, config, context, agentMode
 
 // src/harness/pty/adapters/types.ts
 import { accessSync, constants, statSync } from "fs";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var TuiUnavailableError = class extends Error {
   constructor(tui, message) {
     super(message);
@@ -8658,10 +8448,10 @@ var TuiUnavailableError = class extends Error {
   }
   tui;
 };
-function isExecutable(path3) {
+function isExecutable(path2) {
   try {
-    if (!statSync(path3).isFile()) return false;
-    accessSync(path3, constants.X_OK);
+    if (!statSync(path2).isFile()) return false;
+    accessSync(path2, constants.X_OK);
     return true;
   } catch {
     return false;
@@ -8673,7 +8463,7 @@ function findOnPath(binary, env = process.env) {
   }
   for (const dir of (env.PATH ?? "").split(":")) {
     if (!dir) continue;
-    const candidate = join8(dir, binary);
+    const candidate = join7(dir, binary);
     if (isExecutable(candidate)) return candidate;
   }
   return null;
@@ -9537,10 +9327,10 @@ function resolveSessionStart(lineageKey, cwd) {
   }
   return { sessionId: sessionUuid };
 }
-function repairTornSessionFile(path3) {
+function repairTornSessionFile(path2) {
   try {
-    if (!existsSync2(path3)) return false;
-    const content = readFileSync(path3, "utf8");
+    if (!existsSync2(path2)) return false;
+    const content = readFileSync(path2, "utf8");
     if (content.length === 0) return false;
     let keepEnd = content.length;
     if (!content.endsWith("\n")) {
@@ -9559,9 +9349,9 @@ function repairTornSessionFile(path3) {
       keepEnd = prevNewline + 1;
     }
     if (keepEnd === content.length) return false;
-    truncateSync(path3, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
+    truncateSync(path2, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
     logger2.warn("Repaired torn transcript before resume", {
-      path: path3,
+      path: path2,
       trimmedBytes: content.length - keepEnd
     });
     return true;
@@ -10370,7 +10160,7 @@ var QueryBridge = class {
 
 // src/runner/session-runner-helpers.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join9 } from "path";
+import { dirname as dirname2, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
@@ -10399,7 +10189,7 @@ function readAgentVersion() {
     const here = dirname2(fileURLToPath2(import.meta.url));
     for (const rel of ["../package.json", "../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync2(join9(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync2(join8(here, rel), "utf-8"));
         if (pkg.version) return pkg.version;
       } catch {
       }
@@ -10702,10 +10492,10 @@ import { access, stat as stat2 } from "fs/promises";
 var DEFAULT_FAILED_PATH = "/workspaces/.conveyor-git-failed";
 var DEFAULT_TIMEOUT_MS = 6e5;
 var DEFAULT_POLL_MS = 200;
-async function fileExists(path3) {
+async function fileExists(path2) {
   try {
-    await access(path3);
-    const s = await stat2(path3);
+    await access(path2);
+    const s = await stat2(path2);
     return s.isFile();
   } catch {
     return false;
@@ -10820,9 +10610,9 @@ var DEFAULT_PROC_PATHS = ["/proc/net/tcp", "/proc/net/tcp6"];
 async function readProcListeningPorts(procPaths = DEFAULT_PROC_PATHS) {
   const sockets = [];
   let readable = false;
-  for (const path3 of procPaths) {
+  for (const path2 of procPaths) {
     try {
-      const content = await readFile3(path3, "utf8");
+      const content = await readFile3(path2, "utf8");
       readable = true;
       sockets.push(...parseProcNetTcpListeners(content));
     } catch {
@@ -11049,7 +10839,7 @@ async function handlePullBranch(workDir, branch) {
 
 // src/runner/heavy-gate.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path2 from "path";
+import path from "path";
 var GATE_KEYS = ["heavy", "test", "typecheck", "build"];
 function runDir() {
   return process.env.CONVEYOR_RUN_DIR ?? "/tmp/conveyor-run";
@@ -11065,7 +10855,7 @@ function pidAlive(pid) {
 function isHeavyGateActive() {
   for (const key of GATE_KEYS) {
     try {
-      const raw = readFileSync3(path2.join(runDir(), `${key}.pid`), "utf8").trim();
+      const raw = readFileSync3(path.join(runDir(), `${key}.pid`), "utf8").trim();
       const pid = Number.parseInt(raw, 10);
       if (Number.isInteger(pid) && pid > 0 && pidAlive(pid)) return true;
     } catch {
@@ -11110,6 +10900,12 @@ var SessionRunner = class _SessionRunner {
   portDiscovery;
   /** Main event-loop lag measurement, shared with the heartbeat worker. */
   loopLag = new LoopLagMonitor();
+  /** Boot supervisor handle, set post-construction once it's known (it is
+   *  started alongside connect(), before the runner itself exists in some
+   *  call sites) — notified when the core loop goes live so it can release
+   *  the app's start command. Optional: never set in tests/paths that don't
+   *  wire a supervisor. */
+  workspaceCommands = null;
   constructor(config, callbacks, deps = {}) {
     this.config = config;
     this.callbacks = callbacks;
@@ -11156,6 +10952,12 @@ var SessionRunner = class _SessionRunner {
   get isStopped() {
     return this.stopped;
   }
+  /** Wire the boot supervisor handle post-construction — cli.ts constructs it
+   *  via startWorkspaceCommandsAfterConnect() (which needs connect() to already
+   *  be callable), so it can't be a constructor dependency. */
+  setWorkspaceCommands(supervisor) {
+    this.workspaceCommands = supervisor;
+  }
   // ── Main lifecycle ─────────────────────────────────────────────────
   /**
    * Establish the API connection, wire callbacks, and join the session room.
@@ -11233,39 +11035,27 @@ var SessionRunner = class _SessionRunner {
       await this.shutdown("error");
       return;
     }
-    if (process.env.CONVEYOR_GIT_READY !== "1") {
-      if (this.fullContext?.githubBranch) {
-        await ensureOnTaskBranch(this.config.workspaceDir, this.fullContext.githubBranch);
-      }
-      if (this.fullContext?.baseBranch) {
-        await syncWithBaseBranch(this.config.workspaceDir, this.fullContext.baseBranch);
+    if (this.fullContext?.githubBranch) {
+      const ok = await ensureOnTaskBranch(
+        this.config.workspaceDir,
+        this.fullContext.githubBranch,
+        this.fullContext.baseBranch ?? void 0
+      );
+      if (!ok) {
+        process.stderr.write("[conveyor-agent] WARNING: task-branch checkout failed\n");
       }
     }
     if (!this.stopped) {
       this.lifecycle.startGitFlush();
     }
     if (this.fullContext?.githubBranch) {
-      const snapshotUrl = process.env.CONVEYOR_SNAPSHOT_URL;
-      if (snapshotUrl) {
-        const restore = await restoreOnBoot(
-          { snapshotUrl, gitPlan: { branch: this.fullContext.githubBranch } },
-          this.config.workspaceDir
-        );
-        if (restore.source !== "clean") {
-          process.stderr.write(
-            `[conveyor-agent] WorkPreservation restore: source=${restore.source}${restore.fileCount === void 0 ? "" : ` files=${restore.fileCount}`}
-`
-          );
-        }
-      } else {
-        const restored = await restoreWipSnapshot(
-          this.config.workspaceDir,
-          this.fullContext.githubBranch
-        );
-        if (restored !== "none") {
-          process.stderr.write(`[conveyor-agent] WIP snapshot restore: ${restored}
+      const restored = await restoreWipSnapshot(
+        this.config.workspaceDir,
+        this.fullContext.githubBranch
+      );
+      if (restored !== "none") {
+        process.stderr.write(`[conveyor-agent] WIP snapshot restore: ${restored}
 `);
-        }
       }
     }
     this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
@@ -11300,6 +11090,7 @@ var SessionRunner = class _SessionRunner {
 `
       );
     }
+    this.workspaceCommands?.notifyLoopReady();
     while (!this.stopped) {
       if (this._state !== "idle") await this.setState("idle");
       await this.coreLoop();
@@ -11369,6 +11160,7 @@ var SessionRunner = class _SessionRunner {
           this.interrupted = false;
           continue;
         }
+        await this.flushWipNow("WIP: end of turn");
         if (!this.stopped) await this.setState("idle");
       } else if (this._state === "error") {
         await this.setState("idle");
@@ -11395,6 +11187,7 @@ var SessionRunner = class _SessionRunner {
         "[conveyor-agent] Completed \u2014 entering dormant idle (staying connected)\n"
       );
     }
+    await this.flushWipNow("WIP: turn complete");
     this.pendingMessages.length = 0;
     if (this._state !== "idle") await this.setState("idle");
     const remainingMs = Math.max(0, this.dormantDeadline - Date.now());
@@ -11614,6 +11407,36 @@ var SessionRunner = class _SessionRunner {
     }
   }
   // ── Stop / soft-stop ───────────────────────────────────────────────
+  /** Shared token-refresh closure for the git-flush call sites (periodic
+   *  backstop + per-turn flush). Never throws — returns undefined so the
+   *  caller falls back to its existing remote credentials. */
+  async refreshGithubTokenForFlush() {
+    try {
+      const res = await this.connection.call("refreshGithubToken", {
+        sessionId: this.connection.sessionId
+      });
+      return res.token;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Push uncommitted work to the conveyor-wip ref after a turn. Git-only (no
+   *  GCS). Primary-branch only — cheap enough to run every turn. Shares the
+   *  in-flight guard with the periodic backstop so a turn-end flush and a
+   *  timer tick never overlap. Best-effort, never throws. */
+  async flushWipNow(wipMessage) {
+    if (this.periodicFlushInFlight || this.stopped) return;
+    this.periodicFlushInFlight = true;
+    try {
+      await flushPendingChanges(this.config.workspaceDir, {
+        wipMessage,
+        refreshToken: () => this.refreshGithubTokenForFlush()
+      });
+    } catch {
+    } finally {
+      this.periodicFlushInFlight = false;
+    }
+  }
   /** Periodic best-effort WIP commit + push during normal agent execution.
    *  Covers ungraceful pod termination (OOMKilled, node crash/eviction) where
    *  the preStop hook + SIGTERM flush don't get a chance to run. No-ops on a
@@ -11632,16 +11455,7 @@ var SessionRunner = class _SessionRunner {
     try {
       const result = await flushAllPendingWork(this.config.workspaceDir, {
         wipMessage: "WIP: periodic auto-commit",
-        refreshToken: async () => {
-          try {
-            const res = await this.connection.call("refreshGithubToken", {
-              sessionId: this.connection.sessionId
-            });
-            return res.token;
-          } catch {
-            return void 0;
-          }
-        }
+        refreshToken: () => this.refreshGithubTokenForFlush()
       });
       if (result.hadWork) {
         process.stderr.write(
@@ -11649,7 +11463,6 @@ var SessionRunner = class _SessionRunner {
 `
         );
       }
-      await this.uploadGcsSnapshotIfConfigured();
     } catch {
     } finally {
       this.periodicFlushInFlight = false;
@@ -11675,22 +11488,6 @@ var SessionRunner = class _SessionRunner {
       });
     }
   }
-  /** PUT the WorkPreservation snapshot tar to the bundle's capability URL
-   *  when this pod is v3 (CONVEYOR_SNAPSHOT_UPLOAD_URL set). Never throws. */
-  async uploadGcsSnapshotIfConfigured() {
-    const uploadUrl = process.env.CONVEYOR_SNAPSHOT_UPLOAD_URL;
-    if (!uploadUrl) return;
-    try {
-      const gcs = await uploadSnapshotToGcs(this.config.workspaceDir, uploadUrl);
-      if (gcs.uploaded) {
-        process.stderr.write(
-          `[conveyor-agent] WorkPreservation GCS snapshot: files=${gcs.fileCount} bytes=${gcs.sizeBytes}
-`
-        );
-      }
-    } catch {
-    }
-  }
   /** Best-effort WIP commit + push on shutdown so in-flight work isn't lost
    *  when a claudespace pod is killed. Must be called BEFORE stop() so the
    *  connection is still alive for token refresh. Never throws. */
@@ -11715,7 +11512,6 @@ var SessionRunner = class _SessionRunner {
 `
         );
       }
-      await this.uploadGcsSnapshotIfConfigured();
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[conveyor-agent] Shutdown git flush failed: ${msg}
@@ -11863,37 +11659,6 @@ var SessionRunner = class _SessionRunner {
     this.connection.onPullBranch(({ branch }) => {
       void handlePullBranch(this.config.workspaceDir, branch);
     });
-    this.connection.onFinalizeSnapshot(() => void this.finalizeSnapshotNow());
-  }
-  /** Eager finalize snapshot triggered by the reconciler's sleep signal
-   *  (session:finalizeSnapshot). Runs a full workspace capture and uploads it
-   *  NOW so the sleep confirms on this snapshot instead of waiting for the
-   *  ~2min periodic flush. Sidecar DB state is intentionally NOT captured — it
-   *  is no longer durable across sleep/wake (#2623); only the agent's
-   *  /workspace rides the snapshot. Best-effort: on failure the
-   *  periodic/shutdown path stays the fallback. No-op on non-v3 pods. */
-  async finalizeSnapshotNow() {
-    const uploadUrl = process.env.CONVEYOR_SNAPSHOT_UPLOAD_URL;
-    if (!uploadUrl || this.stopped) return;
-    try {
-      await finalizeForSleep({
-        cwd: this.config.workspaceDir,
-        branch: this.fullContext?.githubBranch ?? "",
-        snapshotUploadUrl: uploadUrl,
-        refreshToken: async () => {
-          try {
-            const res = await this.connection.call("refreshGithubToken", {
-              sessionId: this.connection.sessionId
-            });
-            return res.token;
-          } catch {
-            return void 0;
-          }
-        }
-      });
-      process.stderr.write("[conveyor-agent] Finalize snapshot uploaded on sleep signal\n");
-    } catch {
-    }
   }
   /** Proactively refresh the GitHub token before the 1-hour expiry. */
   async refreshGithubToken() {
@@ -11989,12 +11754,12 @@ var SessionRunner = class _SessionRunner {
 };
 
 // src/setup/config.ts
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readWorkspaceFile(join10(workspaceDir, DEVCONTAINER_PATH));
+    const raw = await readWorkspaceFile(join9(workspaceDir, DEVCONTAINER_PATH));
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -12082,16 +11847,10 @@ export {
   sampleKeyUsage,
   awaitGitReady,
   PortDiscovery,
-  uploadSnapshotToGcs,
-  captureSnapshot,
-  startPeriodic,
-  stop,
-  finalizeForSleep,
-  restoreOnBoot,
   SessionRunner,
   loadForwardPorts,
   buildSessionPreviewPorts,
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-TB5SQIGX.js.map
+//# sourceMappingURL=chunk-J4UH5TOO.js.map