@rallycry/conveyor-agent 10.13.13 → 10.13.14

package/dist/{client-ICIWKSK2.js → client-VQIBGPE6.js}

@@ -4,9 +4,9 @@ import {
   WorkbenchError,
   getWorkbenchClient,
   resetWorkbenchClient
-} from "./chunk-YRC57EYG.js";
+} from "./chunk-LZM5OKAC.js";
 import "./chunk-4VUQ2NPF.js";
-import "./chunk-IE7EOKMD.js";
+import "./chunk-VKZ5W2VO.js";
 export {
   RemoteProcessHandle,
   WorkbenchClient,
@@ -14,4 +14,4 @@ export {
   getWorkbenchClient,
   resetWorkbenchClient
 };
-//# sourceMappingURL=client-ICIWKSK2.js.map
+//# sourceMappingURL=client-VQIBGPE6.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _project_shared from '@project/shared';
-import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload, WorkspaceDiscoveredPort, AgentQuestion, AgentRunnerStatus, BootstrapBundle } from '@project/shared';
+import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload, WorkspaceDiscoveredPort, AgentQuestion, AgentRunnerStatus } from '@project/shared';
 export * from '@project/shared';
 import { ChildProcess } from 'node:child_process';
 
@@ -88,7 +88,6 @@ declare class AgentConnection {
     private modeChangeCallback;
     private apiKeyUpdateCallback;
     private pullBranchCallback;
-    private finalizeSnapshotCallback;
     private runStartCommandCallback;
     private earlyPullBranches;
     private spawnReviewCallback;
@@ -164,7 +163,6 @@ declare class AgentConnection {
      * sessionId is OUR (builder) session — the SEC-9 guard runs on it.
      */
     reportSessionSpawnFailure(spawnedSessionId: string, error?: string): void;
-    onFinalizeSnapshot(callback: () => void): void;
     onRunStartCommand(callback: () => void): void;
     /**
      * Forward a raw chunk of terminal output to the S2 relay (fire-and-forget).
@@ -437,6 +435,12 @@ interface SessionRunnerPortDiscovery {
     start(): Promise<void>;
     stop(): void;
 }
+/** Duck-typed handle onto the boot supervisor — just enough surface for the
+ *  runner to release the app's start command once the core loop is live.
+ *  Avoids importing the concrete WorkspaceCommandSupervisor class here. */
+interface SessionRunnerWorkspaceCommands {
+    notifyLoopReady(): void;
+}
 interface SessionRunnerDependencies {
     portDiscovery?: SessionRunnerPortDiscovery;
 }
@@ -474,10 +478,20 @@ declare class SessionRunner {
     private readonly portDiscovery;
     /** Main event-loop lag measurement, shared with the heartbeat worker. */
     private readonly loopLag;
+    /** 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. */
+    private workspaceCommands;
     constructor(config: SessionRunnerConfig, callbacks: SessionRunnerCallbacks, deps?: SessionRunnerDependencies);
     get state(): AgentRunnerStatus;
     get sessionId(): string;
     get isStopped(): boolean;
+    /** 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: SessionRunnerWorkspaceCommands | null): void;
     /**
      * Establish the API connection, wire callbacks, and join the session room.
      * Call this before run() when you need to send events (e.g. setup/start
@@ -558,6 +572,15 @@ declare class SessionRunner {
     private onPassiveTuiActivity;
     /** Run queryBridge.executePassive, swallowing abort errors from stop/softStop. */
     private executePassive;
+    /** 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. */
+    private refreshGithubTokenForFlush;
+    /** 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. */
+    private flushWipNow;
     /** 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
@@ -570,9 +593,6 @@ declare class SessionRunner {
      *  `selectBestKey` rotation honest. Best-effort — never throws, no-op when the
      *  pod has no OAuth token (e.g. API-key projects). */
     private sampleAndReportKeyUsage;
-    /** PUT the WorkPreservation snapshot tar to the bundle's capability URL
-     *  when this pod is v3 (CONVEYOR_SNAPSHOT_UPLOAD_URL set). Never throws. */
-    private uploadGcsSnapshotIfConfigured;
     /** 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. */
@@ -582,14 +602,6 @@ declare class SessionRunner {
     private buildFullContext;
     private createQueryBridge;
     private wireConnectionCallbacks;
-    /** 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. */
-    private finalizeSnapshotNow;
     /** Proactively refresh the GitHub token before the 1-hour expiry. */
     private refreshGithubToken;
     /** Re-fetch task context to pick up a newly created branch and check it out. */
@@ -659,67 +671,6 @@ declare function detachWorktreeBranch(projectDir: string, branch: string): Promi
  */
 declare function removeWorktree(projectDir: string, taskId: string): Promise<void>;
 
-interface CaptureContext {
-    cwd: string;
-    branch: string;
-    snapshotUploadUrl?: string;
-    refreshToken?: () => Promise<string | undefined>;
-    wipMessage?: string;
-    /** Force the GCS PUT even when the tar is empty (sizeBytes === 0). Used by the
-     *  sleep FINALIZE path so `snapshotAt` is stamped and the reconciler's
-     *  teardown confirm lands immediately — an empty workspace is a valid (empty)
-     *  snapshot; on wake the restore's manifest check falls back to a clean
-     *  checkout. The periodic path leaves this false so a racing empty capture
-     *  never clobbers a good snapshot. */
-    forceUpload?: boolean;
-}
-interface SnapshotArtifact {
-    fileCount: number;
-    deletionCount: number;
-    sizeBytes: number;
-    gcsUploaded: boolean;
-    wipPushed: boolean;
-}
-interface RestoreResult {
-    source: "gcs" | "wip" | "clean";
-    fileCount?: number;
-}
-interface GcsUploadResult {
-    uploaded: boolean;
-    fileCount: number;
-    deletionCount: number;
-    sizeBytes: number;
-}
-/**
- * The GCS sink on its own: assemble the snapshot tar (the single capture
- * path) and PUT it to the capability URL. Exposed so a runner whose git-tier
- * flush is driven elsewhere (SessionRunner's periodic flushAllPendingWork)
- * can add the GCS sink to the SAME trigger instead of running a second,
- * racing snapshotter. Calls are serialized: a later capture always PUTs
- * after any earlier in-flight one has settled.
- */
-declare function uploadSnapshotToGcs(cwd: string, uploadUrl: string | undefined, opts?: {
-    forceUpload?: boolean;
-}): Promise<GcsUploadResult>;
-declare function captureSnapshot(ctx: CaptureContext): Promise<SnapshotArtifact>;
-declare function startPeriodic(intervalMs: number, ctx: CaptureContext): void;
-declare function stop(): void;
-declare function finalizeForSleep(ctx: CaptureContext): Promise<SnapshotArtifact>;
-/**
- * Restore precedence at boot: GCS snapshot (tracked+untracked+deletions),
- * else the conveyor-wip ref, else a clean checkout. Accepts the narrow slice
- * of the bundle it reads so v3 pods can call it from env-derived values
- * (CONVEYOR_SNAPSHOT_URL + the task branch) as well as from a full bundle.
- *
- * GCS is only authoritative when the archive's manifest HEAD matches the
- * current clone (checked BEFORE any tree mutation) — a stale or invalid
- * snapshot leaves the tree untouched and falls through to the wip ref, whose
- * own parent-HEAD guard handles staleness.
- */
-declare function restoreOnBoot(bundle: Pick<BootstrapBundle, "snapshotUrl"> & {
-    gitPlan: Pick<BootstrapBundle["gitPlan"], "branch">;
-}, cwd: string): Promise<RestoreResult>;
-
 interface ConveyorConfig {
     setupCommand?: string;
     startCommand?: string;
@@ -742,4 +693,4 @@ declare function runStartCommand(cmd: string, cwd: string, onOutput: (stream: "s
 /** Fetch full git history if the repo was cloned with --depth=1. */
 declare function unshallowRepo(workspaceDir: string): void;
 
-export { AgentConnection, type AgentConnectionConfig, type AgentRunnerCallbacks, type AgentRunnerConfig, type ApiKeyUpdateData, type CaptureContext, type ConveyorConfig, type GcsUploadResult, type IncomingMessage, type LifecycleCallbacks, type LifecycleConfig, type ModeAction, type ModeTaskContext, type RestoreResult, SessionRunner, type SessionRunnerCallbacks, type SessionRunnerConfig, type SetModeData, type SnapshotArtifact, captureSnapshot, detachWorktreeBranch, ensureWorktree, finalizeForSleep, flushPendingChanges, getCurrentBranch, hasUncommittedChanges, hasUnpushedCommits, loadConveyorConfig, loadForwardPorts, pushToOrigin, removeWorktree, restoreOnBoot, runAuthTokenCommand, runSetupCommand, runStartCommand, stageAndCommit, startPeriodic as startWorkPreservation, stop as stopWorkPreservation, unshallowRepo, updateRemoteToken, uploadSnapshotToGcs };
+export { AgentConnection, type AgentConnectionConfig, type AgentRunnerCallbacks, type AgentRunnerConfig, type ApiKeyUpdateData, type ConveyorConfig, type IncomingMessage, type LifecycleCallbacks, type LifecycleConfig, type ModeAction, type ModeTaskContext, SessionRunner, type SessionRunnerCallbacks, type SessionRunnerConfig, type SetModeData, detachWorktreeBranch, ensureWorktree, flushPendingChanges, getCurrentBranch, hasUncommittedChanges, hasUnpushedCommits, loadConveyorConfig, loadForwardPorts, pushToOrigin, removeWorktree, runAuthTokenCommand, runSetupCommand, runStartCommand, stageAndCommit, unshallowRepo, updateRemoteToken };

package/dist/index.js

@@ -2,8 +2,6 @@ import {
   AgentConnection,
   GIT_TIMEOUT_MS,
   SessionRunner,
-  captureSnapshot,
-  finalizeForSleep,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
@@ -11,19 +9,15 @@ import {
   loadConveyorConfig,
   loadForwardPorts,
   pushToOrigin,
-  restoreOnBoot,
   stageAndCommit,
-  startPeriodic,
-  stop,
   unshallowRepo,
   updateRemoteToken,
-  uploadSnapshotToGcs,
   workspacePathExists
-} from "./chunk-TB5SQIGX.js";
+} from "./chunk-J4UH5TOO.js";
 import "./chunk-7TQO4ZF4.js";
 import {
   getWorkbenchClient
-} from "./chunk-YRC57EYG.js";
+} from "./chunk-LZM5OKAC.js";
 import {
   workbenchEnabled
 } from "./chunk-4VUQ2NPF.js";
@@ -31,8 +25,8 @@ import {
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand
-} from "./chunk-2K6RRTQC.js";
-import "./chunk-IE7EOKMD.js";
+} from "./chunk-RSIW2UCR.js";
+import "./chunk-VKZ5W2VO.js";
 
 // src/runner/worktree.ts
 import { execFile } from "child_process";
@@ -102,10 +96,8 @@ async function removeWorktree(projectDir, taskId) {
 export {
   AgentConnection,
   SessionRunner,
-  captureSnapshot,
   detachWorktreeBranch,
   ensureWorktree,
-  finalizeForSleep,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
@@ -114,15 +106,11 @@ export {
   loadForwardPorts,
   pushToOrigin,
   removeWorktree,
-  restoreOnBoot,
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand,
   stageAndCommit,
-  startPeriodic as startWorkPreservation,
-  stop as stopWorkPreservation,
   unshallowRepo,
-  updateRemoteToken,
-  uploadSnapshotToGcs
+  updateRemoteToken
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner/worktree.ts"],"sourcesContent":["import { execFile } from \"node:child_process\";\nimport { join } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { GIT_TIMEOUT_MS, hasUncommittedChanges } from \"./git-utils.js\";\nimport { getWorkbenchClient } from \"../workbench/client.js\";\nimport { workbenchEnabled } from \"../workbench/mode.js\";\nimport { workspacePathExists } from \"../workbench/fs.js\";\n\n// Async git (execFile, no shell) — synchronous child processes freeze the\n// agent's event loop and starve the socket heartbeat; see git-utils.ts.\n// Split-mode pods route over the launcher (the repo lives in the workbench).\nconst execFileAsync = promisify(execFile);\n\nasync function git(cwd: string, args: string[]): Promise<string> {\n  if (workbenchEnabled()) {\n    const { stdout } = await getWorkbenchClient().execFile(\"git\", args, {\n      cwd,\n      timeout: GIT_TIMEOUT_MS,\n    });\n    return stdout;\n  }\n  const { stdout } = await execFileAsync(\"git\", args, { cwd, timeout: GIT_TIMEOUT_MS });\n  return stdout.toString();\n}\n\nconst WORKTREE_DIR = \".worktrees\";\n\nexport async function ensureWorktree(\n  projectDir: string,\n  taskId: string,\n  branch?: string,\n): Promise<string> {\n  if (projectDir.includes(`/${WORKTREE_DIR}/`)) {\n    return projectDir;\n  }\n\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n\n  if (await workspacePathExists(worktreePath)) {\n    if (branch) {\n      if (await hasUncommittedChanges(worktreePath)) {\n        return worktreePath;\n      }\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\", `origin/${branch}`]);\n      } catch {\n        /* branch doesn't exist on remote yet */\n      }\n    }\n    return worktreePath;\n  }\n\n  const ref = branch ? `origin/${branch}` : \"HEAD\";\n  await git(projectDir, [\"worktree\", \"add\", \"--detach\", worktreePath, ref]);\n\n  return worktreePath;\n}\n\n/**\n * Detach any task worktree that has `branch` checked out, releasing the branch lock\n * so the main project directory can check it out. Only touches worktrees inside\n * `.worktrees/` — never the main project directory.\n */\nexport async function detachWorktreeBranch(projectDir: string, branch: string): Promise<void> {\n  try {\n    const output = await git(projectDir, [\"worktree\", \"list\", \"--porcelain\"]);\n    const entries = output.split(\"\\n\\n\");\n    for (const entry of entries) {\n      const lines = entry.trim().split(\"\\n\");\n      const worktreeLine = lines.find((l) => l.startsWith(\"worktree \"));\n      const branchLine = lines.find((l) => l.startsWith(\"branch \"));\n      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;\n\n      const worktreePath = worktreeLine.replace(\"worktree \", \"\");\n      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;\n\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\"]);\n      } catch {\n        /* best effort */\n      }\n    }\n  } catch {\n    /* best effort */\n  }\n}\n\n/**\n * Force-remove is intentional: this runs after task completion or explicit stop.\n * Any uncommitted changes at this point are scratch artifacts, not valuable work.\n */\nexport async function removeWorktree(projectDir: string, taskId: string): Promise<void> {\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n  if (!(await workspacePathExists(worktreePath))) return;\n  try {\n    await git(projectDir, [\"worktree\", \"remove\", worktreePath, \"--force\"]);\n  } catch {\n    /* best effort */\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAS1B,IAAM,gBAAgB,UAAU,QAAQ;AAExC,eAAe,IAAI,KAAa,MAAiC;AAC/D,MAAI,iBAAiB,GAAG;AACtB,UAAM,EAAE,QAAAA,QAAO,IAAI,MAAM,mBAAmB,EAAE,SAAS,OAAO,MAAM;AAAA,MAClE;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,WAAOA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,IAAI,MAAM,cAAc,OAAO,MAAM,EAAE,KAAK,SAAS,eAAe,CAAC;AACpF,SAAO,OAAO,SAAS;AACzB;AAEA,IAAM,eAAe;AAErB,eAAsB,eACpB,YACA,QACA,QACiB;AACjB,MAAI,WAAW,SAAS,IAAI,YAAY,GAAG,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAE1D,MAAI,MAAM,oBAAoB,YAAY,GAAG;AAC3C,QAAI,QAAQ;AACV,UAAI,MAAM,sBAAsB,YAAY,GAAG;AAC7C,eAAO;AAAA,MACT;AACA,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,YAAY,UAAU,MAAM,EAAE,CAAC;AAAA,MACtE,QAAQ;AAAA,MAER;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,SAAS,UAAU,MAAM,KAAK;AAC1C,QAAM,IAAI,YAAY,CAAC,YAAY,OAAO,YAAY,cAAc,GAAG,CAAC;AAExE,SAAO;AACT;AAOA,eAAsB,qBAAqB,YAAoB,QAA+B;AAC5F,MAAI;AACF,UAAM,SAAS,MAAM,IAAI,YAAY,CAAC,YAAY,QAAQ,aAAa,CAAC;AACxE,UAAM,UAAU,OAAO,MAAM,MAAM;AACnC,eAAW,SAAS,SAAS;AAC3B,YAAM,QAAQ,MAAM,KAAK,EAAE,MAAM,IAAI;AACrC,YAAM,eAAe,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,WAAW,CAAC;AAChE,YAAM,aAAa,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,CAAC;AAC5D,UAAI,CAAC,gBAAgB,eAAe,qBAAqB,MAAM,GAAI;AAEnE,YAAM,eAAe,aAAa,QAAQ,aAAa,EAAE;AACzD,UAAI,CAAC,aAAa,SAAS,IAAI,YAAY,GAAG,EAAG;AAEjD,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,UAAU,CAAC;AAAA,MAClD,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACF;AAMA,eAAsB,eAAe,YAAoB,QAA+B;AACtF,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAC1D,MAAI,CAAE,MAAM,oBAAoB,YAAY,EAAI;AAChD,MAAI;AACF,UAAM,IAAI,YAAY,CAAC,YAAY,UAAU,cAAc,SAAS,CAAC;AAAA,EACvE,QAAQ;AAAA,EAER;AACF;","names":["stdout"]}
+{"version":3,"sources":["../src/runner/worktree.ts"],"sourcesContent":["import { execFile } from \"node:child_process\";\nimport { join } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { GIT_TIMEOUT_MS, hasUncommittedChanges } from \"./git-utils.js\";\nimport { getWorkbenchClient } from \"../workbench/client.js\";\nimport { workbenchEnabled } from \"../workbench/mode.js\";\nimport { workspacePathExists } from \"../workbench/fs.js\";\n\n// Async git (execFile, no shell) — synchronous child processes freeze the\n// agent's event loop and starve the socket heartbeat; see git-utils.ts.\n// Split-mode pods route over the launcher (the repo lives in the workbench).\nconst execFileAsync = promisify(execFile);\n\nasync function git(cwd: string, args: string[]): Promise<string> {\n  if (workbenchEnabled()) {\n    const { stdout } = await getWorkbenchClient().execFile(\"git\", args, {\n      cwd,\n      timeout: GIT_TIMEOUT_MS,\n    });\n    return stdout;\n  }\n  const { stdout } = await execFileAsync(\"git\", args, { cwd, timeout: GIT_TIMEOUT_MS });\n  return stdout.toString();\n}\n\nconst WORKTREE_DIR = \".worktrees\";\n\nexport async function ensureWorktree(\n  projectDir: string,\n  taskId: string,\n  branch?: string,\n): Promise<string> {\n  if (projectDir.includes(`/${WORKTREE_DIR}/`)) {\n    return projectDir;\n  }\n\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n\n  if (await workspacePathExists(worktreePath)) {\n    if (branch) {\n      if (await hasUncommittedChanges(worktreePath)) {\n        return worktreePath;\n      }\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\", `origin/${branch}`]);\n      } catch {\n        /* branch doesn't exist on remote yet */\n      }\n    }\n    return worktreePath;\n  }\n\n  const ref = branch ? `origin/${branch}` : \"HEAD\";\n  await git(projectDir, [\"worktree\", \"add\", \"--detach\", worktreePath, ref]);\n\n  return worktreePath;\n}\n\n/**\n * Detach any task worktree that has `branch` checked out, releasing the branch lock\n * so the main project directory can check it out. Only touches worktrees inside\n * `.worktrees/` — never the main project directory.\n */\nexport async function detachWorktreeBranch(projectDir: string, branch: string): Promise<void> {\n  try {\n    const output = await git(projectDir, [\"worktree\", \"list\", \"--porcelain\"]);\n    const entries = output.split(\"\\n\\n\");\n    for (const entry of entries) {\n      const lines = entry.trim().split(\"\\n\");\n      const worktreeLine = lines.find((l) => l.startsWith(\"worktree \"));\n      const branchLine = lines.find((l) => l.startsWith(\"branch \"));\n      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;\n\n      const worktreePath = worktreeLine.replace(\"worktree \", \"\");\n      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;\n\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\"]);\n      } catch {\n        /* best effort */\n      }\n    }\n  } catch {\n    /* best effort */\n  }\n}\n\n/**\n * Force-remove is intentional: this runs after task completion or explicit stop.\n * Any uncommitted changes at this point are scratch artifacts, not valuable work.\n */\nexport async function removeWorktree(projectDir: string, taskId: string): Promise<void> {\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n  if (!(await workspacePathExists(worktreePath))) return;\n  try {\n    await git(projectDir, [\"worktree\", \"remove\", worktreePath, \"--force\"]);\n  } catch {\n    /* best effort */\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAS1B,IAAM,gBAAgB,UAAU,QAAQ;AAExC,eAAe,IAAI,KAAa,MAAiC;AAC/D,MAAI,iBAAiB,GAAG;AACtB,UAAM,EAAE,QAAAA,QAAO,IAAI,MAAM,mBAAmB,EAAE,SAAS,OAAO,MAAM;AAAA,MAClE;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,WAAOA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,IAAI,MAAM,cAAc,OAAO,MAAM,EAAE,KAAK,SAAS,eAAe,CAAC;AACpF,SAAO,OAAO,SAAS;AACzB;AAEA,IAAM,eAAe;AAErB,eAAsB,eACpB,YACA,QACA,QACiB;AACjB,MAAI,WAAW,SAAS,IAAI,YAAY,GAAG,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAE1D,MAAI,MAAM,oBAAoB,YAAY,GAAG;AAC3C,QAAI,QAAQ;AACV,UAAI,MAAM,sBAAsB,YAAY,GAAG;AAC7C,eAAO;AAAA,MACT;AACA,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,YAAY,UAAU,MAAM,EAAE,CAAC;AAAA,MACtE,QAAQ;AAAA,MAER;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,SAAS,UAAU,MAAM,KAAK;AAC1C,QAAM,IAAI,YAAY,CAAC,YAAY,OAAO,YAAY,cAAc,GAAG,CAAC;AAExE,SAAO;AACT;AAOA,eAAsB,qBAAqB,YAAoB,QAA+B;AAC5F,MAAI;AACF,UAAM,SAAS,MAAM,IAAI,YAAY,CAAC,YAAY,QAAQ,aAAa,CAAC;AACxE,UAAM,UAAU,OAAO,MAAM,MAAM;AACnC,eAAW,SAAS,SAAS;AAC3B,YAAM,QAAQ,MAAM,KAAK,EAAE,MAAM,IAAI;AACrC,YAAM,eAAe,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,WAAW,CAAC;AAChE,YAAM,aAAa,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,CAAC;AAC5D,UAAI,CAAC,gBAAgB,eAAe,qBAAqB,MAAM,GAAI;AAEnE,YAAM,eAAe,aAAa,QAAQ,aAAa,EAAE;AACzD,UAAI,CAAC,aAAa,SAAS,IAAI,YAAY,GAAG,EAAG;AAEjD,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,UAAU,CAAC;AAAA,MAClD,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACF;AAMA,eAAsB,eAAe,YAAoB,QAA+B;AACtF,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAC1D,MAAI,CAAE,MAAM,oBAAoB,YAAY,EAAI;AAChD,MAAI;AACF,UAAM,IAAI,YAAY,CAAC,YAAY,UAAU,cAAc,SAAS,CAAC;AAAA,EACvE,QAAQ;AAAA,EAER;AACF;","names":["stdout"]}

package/dist/{protocol-QJRHTTMQ.js → protocol-IHRTO5C4.js}

@@ -4,7 +4,7 @@ import {
   parseLine,
   timingSafeTokenEqual,
   writeFrame
-} from "./chunk-IE7EOKMD.js";
+} from "./chunk-VKZ5W2VO.js";
 export {
   DEFAULT_WORKBENCH_PORT,
   FrameReader,
@@ -12,4 +12,4 @@ export {
   timingSafeTokenEqual,
   writeFrame
 };
-//# sourceMappingURL=protocol-QJRHTTMQ.js.map
+//# sourceMappingURL=protocol-IHRTO5C4.js.map

package/dist/{server-UGE67KIZ.js → server-TVIXWCAI.js}

@@ -1,23 +1,18 @@
 import {
-  buildSnapshotTar,
-  extractSnapshotTar,
   loadPtySpawn,
   terminateProcessGroup
-} from "./chunk-2K6RRTQC.js";
+} from "./chunk-RSIW2UCR.js";
 import {
   FrameReader,
   timingSafeTokenEqual,
   writeFrame
-} from "./chunk-IE7EOKMD.js";
+} from "./chunk-VKZ5W2VO.js";
 
 // src/workbench/server.ts
 import { spawn } from "child_process";
-import { createReadStream, createWriteStream } from "fs";
-import { mkdtemp, readdir, readFile, rm, stat } from "fs/promises";
+import { readdir, readFile, stat } from "fs/promises";
 import { createServer } from "net";
-import { tmpdir } from "os";
-import { join } from "path";
-var TAR_CHUNK_BYTES = 64 * 1024;
+var READ_CHUNK_BYTES = 64 * 1024;
 function errCode(err) {
   return typeof err?.code === "string" ? err.code : void 0;
 }
@@ -90,12 +85,6 @@ function dispatch(socket, req, sink, opts) {
     case "pty":
       void runPty(socket, req, sink);
       return;
-    case "snapshotBuild":
-      void runSnapshotBuild(socket, req);
-      return;
-    case "snapshotExtract":
-      void runSnapshotExtract(socket, req, sink);
-      return;
     case "readFile":
       void runReadFile(socket, req);
       return;
@@ -203,67 +192,13 @@ async function runPty(socket, req, sink) {
     }
   });
 }
-async function runSnapshotBuild(socket, req) {
-  try {
-    const result = await buildSnapshotTar(req.cwd);
-    try {
-      writeFrame(socket, {
-        t: "meta",
-        sizeBytes: result.sizeBytes,
-        fileCount: result.fileCount,
-        deletionCount: result.deletionCount,
-        capturedAt: result.capturedAt
-      });
-      await new Promise((resolve, reject) => {
-        const stream = createReadStream(result.tarPath, { highWaterMark: TAR_CHUNK_BYTES });
-        stream.on("data", (chunk) => {
-          writeFrame(socket, { t: "data", d: Buffer.from(chunk).toString("base64") });
-        });
-        stream.on("end", () => resolve());
-        stream.on("error", reject);
-        socket.on("close", () => stream.destroy());
-      });
-      writeFrame(socket, { t: "end" });
-    } finally {
-      await result.cleanup();
-    }
-  } catch (err) {
-    sendError(socket, err);
-  }
-  socket.end();
-}
-async function runSnapshotExtract(socket, req, sink) {
-  const staging = await mkdtemp(join(tmpdir(), "conveyor-workbench-extract-"));
-  const tarPath = join(staging, "snapshot.tar.gz");
-  const out = createWriteStream(tarPath);
-  try {
-    await new Promise((resolve, reject) => {
-      sink.setHandler((frame) => {
-        if (frame.t === "data" && typeof frame.d === "string") {
-          out.write(Buffer.from(frame.d, "base64"));
-        } else if (frame.t === "end") {
-          out.end(() => resolve());
-        }
-      });
-      out.on("error", reject);
-      socket.on("close", () => reject(new Error("connection closed before end frame")));
-    });
-    const value = await extractSnapshotTar(req.cwd, tarPath);
-    writeFrame(socket, { t: "result", value });
-  } catch (err) {
-    sendError(socket, err);
-  } finally {
-    await rm(staging, { recursive: true, force: true }).catch(() => void 0);
-    socket.end();
-  }
-}
 async function runReadFile(socket, req) {
   try {
     const content = await readFile(req.path);
-    for (let offset = 0; offset < content.length; offset += TAR_CHUNK_BYTES) {
+    for (let offset = 0; offset < content.length; offset += READ_CHUNK_BYTES) {
       writeFrame(socket, {
         t: "data",
-        d: content.subarray(offset, offset + TAR_CHUNK_BYTES).toString("base64")
+        d: content.subarray(offset, offset + READ_CHUNK_BYTES).toString("base64")
       });
     }
     writeFrame(socket, { t: "end" });
@@ -310,4 +245,4 @@ async function runReaddir(socket, req) {
 export {
   startWorkbenchServer
 };
-//# sourceMappingURL=server-UGE67KIZ.js.map
+//# sourceMappingURL=server-TVIXWCAI.js.map

package/dist/server-TVIXWCAI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/workbench/server.ts"],"sourcesContent":["/**\n * The workbench launcher — PID 1 of the workbench container in split-mode\n * pods (CONVEYOR_MODE=workbench). A token-authed, loopback-only exec daemon:\n * the agent container drives every workspace-touching operation through it\n * (shell commands, the claude PTY, git, file reads) while staying insulated\n * from workload OOMs in its own container cgroup.\n *\n * One connection = one operation. A dropped connection kills the operation's\n * process (group) — the agent dying, restarting, or timing out must never\n * leave orphans accumulating against the workbench memory budget.\n */\n\nimport { spawn, type ChildProcess } from \"node:child_process\";\nimport { readdir, readFile, stat } from \"node:fs/promises\";\nimport { createServer, type Socket } from \"node:net\";\nimport { terminateProcessGroup } from \"../setup/commands.js\";\nimport { loadPtySpawn, type PtyProcess } from \"../harness/pty/pty-support.js\";\nimport {\n  FrameReader,\n  timingSafeTokenEqual,\n  writeFrame,\n  type WorkbenchFrame,\n  type WorkbenchRequest,\n} from \"./protocol.js\";\n\nconst READ_CHUNK_BYTES = 64 * 1024;\n\nexport interface WorkbenchServerOptions {\n  port: number;\n  token: string;\n  version: string;\n}\n\nexport interface WorkbenchServerHandle {\n  port: number;\n  close(): Promise<void>;\n}\n\nfunction errCode(err: unknown): string | undefined {\n  return typeof (err as { code?: unknown })?.code === \"string\"\n    ? (err as { code: string }).code\n    : undefined;\n}\n\nfunction sendError(socket: Socket, err: unknown): void {\n  const frame: WorkbenchFrame = {\n    t: \"error\",\n    message: err instanceof Error ? err.message : String(err),\n    ...(errCode(err) ? { code: errCode(err) } : {}),\n  };\n  writeFrame(socket, frame);\n}\n\n/** Merge request env over the daemon's own (mirrors the local spawn paths,\n *  which inherit process.env and let callers override). */\nfunction mergedEnv(overrides?: Record<string, string>): NodeJS.ProcessEnv {\n  return overrides ? { ...process.env, ...overrides } : { ...process.env };\n}\n\n/**\n * Post-dispatch inbound frames for the connection's operation. Handlers\n * assign `onNext`; frames arriving before assignment are queued so an input\n * racing the (async) pty spawn is never dropped.\n */\nclass FrameSink {\n  private pending: WorkbenchFrame[] = [];\n  private handler: ((frame: WorkbenchFrame) => void) | null = null;\n\n  push(frame: WorkbenchFrame): void {\n    if (this.handler) this.handler(frame);\n    else this.pending.push(frame);\n  }\n\n  setHandler(handler: (frame: WorkbenchFrame) => void): void {\n    this.handler = handler;\n    for (const frame of this.pending.splice(0)) handler(frame);\n  }\n}\n\nexport async function startWorkbenchServer(\n  opts: WorkbenchServerOptions,\n): Promise<WorkbenchServerHandle> {\n  const server = createServer((socket) => handleConnection(socket, opts));\n  await new Promise<void>((resolve, reject) => {\n    server.once(\"error\", reject);\n    server.listen(opts.port, \"127.0.0.1\", () => resolve());\n  });\n  const address = server.address();\n  const port = typeof address === \"object\" && address ? address.port : opts.port;\n  return {\n    port,\n    close: () =>\n      new Promise<void>((resolve) => {\n        server.close(() => resolve());\n      }),\n  };\n}\n\nfunction handleConnection(socket: Socket, opts: WorkbenchServerOptions): void {\n  socket.on(\"error\", () => undefined);\n  const sink = new FrameSink();\n  let dispatched = false;\n  const reader = new FrameReader((frame) => {\n    if (dispatched) {\n      sink.push(frame as unknown as WorkbenchFrame);\n      return;\n    }\n    dispatched = true;\n    dispatch(socket, frame as unknown as WorkbenchRequest, sink, opts);\n  });\n  socket.on(\"data\", (chunk: Buffer) => reader.push(chunk));\n}\n\nfunction dispatch(\n  socket: Socket,\n  req: WorkbenchRequest,\n  sink: FrameSink,\n  opts: WorkbenchServerOptions,\n): void {\n  if (!req || typeof req !== \"object\" || !timingSafeTokenEqual(req.token ?? \"\", opts.token)) {\n    writeFrame(socket, { t: \"error\", message: \"unauthorized\", code: \"unauthorized\" });\n    socket.destroy();\n    return;\n  }\n  switch (req.op) {\n    case \"ping\":\n      writeFrame(socket, { t: \"pong\", version: opts.version });\n      socket.end();\n      return;\n    case \"exec\":\n      runExec(socket, req, sink);\n      return;\n    case \"pty\":\n      void runPty(socket, req, sink);\n      return;\n    case \"readFile\":\n      void runReadFile(socket, req);\n      return;\n    case \"stat\":\n      void runStat(socket, req);\n      return;\n    case \"readdir\":\n      void runReaddir(socket, req);\n      return;\n    default:\n      writeFrame(socket, { t: \"error\", message: \"unknown op\", code: \"bad_request\" });\n      socket.end();\n  }\n}\n\nfunction runExec(\n  socket: Socket,\n  req: Extract<WorkbenchRequest, { op: \"exec\" }>,\n  sink: FrameSink,\n): void {\n  let child: ChildProcess;\n  try {\n    // Argv form (git and friends) spawns directly with no shell; shell form\n    // (setup/start commands) mirrors the local `spawn(\"sh\", [\"-c\", cmd])`.\n    const [argvFile, ...argvRest] = req.argv ?? [];\n    child = argvFile\n      ? spawn(argvFile, argvRest, {\n          cwd: req.cwd,\n          stdio: [\"ignore\", \"pipe\", \"pipe\"],\n          detached: true,\n          env: mergedEnv(req.env),\n        })\n      : spawn(\"sh\", [\"-c\", req.command ?? \"\"], {\n          cwd: req.cwd,\n          stdio: [\"ignore\", \"pipe\", \"pipe\"],\n          detached: true,\n          env: mergedEnv(req.env),\n        });\n  } catch (err) {\n    sendError(socket, err);\n    socket.end();\n    return;\n  }\n\n  let settled = false;\n  sink.setHandler((frame) => {\n    if (frame.t === \"signal\" && frame.mode === \"term-group\" && !settled) {\n      void terminateProcessGroup(child);\n    }\n  });\n  child.stdout?.on(\"data\", (chunk: Buffer) => {\n    writeFrame(socket, { t: \"out\", s: \"stdout\", d: chunk.toString(\"base64\") });\n  });\n  child.stderr?.on(\"data\", (chunk: Buffer) => {\n    writeFrame(socket, { t: \"out\", s: \"stderr\", d: chunk.toString(\"base64\") });\n  });\n  child.on(\"close\", (code, signal) => {\n    settled = true;\n    writeFrame(socket, { t: \"exit\", code, signal });\n    socket.end();\n  });\n  child.on(\"error\", (err) => {\n    if (settled) return;\n    settled = true;\n    sendError(socket, err);\n    socket.end();\n  });\n  // Agent gone (crash, timeout-abort, container death) → no orphans.\n  socket.on(\"close\", () => {\n    if (!settled) void terminateProcessGroup(child);\n  });\n}\n\nasync function runPty(\n  socket: Socket,\n  req: Extract<WorkbenchRequest, { op: \"pty\" }>,\n  sink: FrameSink,\n): Promise<void> {\n  let pty: PtyProcess;\n  try {\n    const ptySpawn = await loadPtySpawn();\n    pty = ptySpawn(req.file, req.args, {\n      name: \"xterm-color\",\n      cols: req.cols,\n      rows: req.rows,\n      cwd: req.cwd,\n      env: req.env,\n    });\n  } catch (err) {\n    sendError(socket, err);\n    socket.end();\n    return;\n  }\n\n  let exited = false;\n  sink.setHandler((frame) => {\n    try {\n      if (frame.t === \"input\" && typeof frame.d === \"string\") {\n        pty.write(Buffer.from(frame.d, \"base64\").toString(\"utf8\"));\n      } else if (\n        frame.t === \"resize\" &&\n        typeof frame.cols === \"number\" &&\n        typeof frame.rows === \"number\"\n      ) {\n        pty.resize(frame.cols, frame.rows);\n      } else if (frame.t === \"kill\") {\n        pty.kill(typeof frame.sig === \"string\" ? frame.sig : undefined);\n      }\n    } catch {\n      /* pty already dead — exit handler owns teardown */\n    }\n  });\n  pty.onData((data) => {\n    writeFrame(socket, { t: \"data\", d: Buffer.from(data, \"utf8\").toString(\"base64\") });\n  });\n  pty.onExit((event) => {\n    exited = true;\n    writeFrame(socket, { t: \"exit\", code: event.exitCode, signal: null });\n    socket.end();\n  });\n  socket.on(\"close\", () => {\n    if (!exited) {\n      try {\n        pty.kill();\n      } catch {\n        /* already dead */\n      }\n    }\n  });\n}\n\nasync function runReadFile(\n  socket: Socket,\n  req: Extract<WorkbenchRequest, { op: \"readFile\" }>,\n): Promise<void> {\n  try {\n    const content = await readFile(req.path);\n    for (let offset = 0; offset < content.length; offset += READ_CHUNK_BYTES) {\n      writeFrame(socket, {\n        t: \"data\",\n        d: content.subarray(offset, offset + READ_CHUNK_BYTES).toString(\"base64\"),\n      });\n    }\n    writeFrame(socket, { t: \"end\" });\n  } catch (err) {\n    sendError(socket, err);\n  }\n  socket.end();\n}\n\nasync function runStat(\n  socket: Socket,\n  req: Extract<WorkbenchRequest, { op: \"stat\" }>,\n): Promise<void> {\n  try {\n    const s = await stat(req.path);\n    writeFrame(socket, {\n      t: \"stat\",\n      exists: true,\n      isFile: s.isFile(),\n      isDirectory: s.isDirectory(),\n      size: s.size,\n      mtimeMs: s.mtimeMs,\n    });\n  } catch (err) {\n    if (errCode(err) === \"ENOENT\") {\n      writeFrame(socket, {\n        t: \"stat\",\n        exists: false,\n        isFile: false,\n        isDirectory: false,\n        size: 0,\n        mtimeMs: 0,\n      });\n    } else {\n      sendError(socket, err);\n    }\n  }\n  socket.end();\n}\n\nasync function runReaddir(\n  socket: Socket,\n  req: Extract<WorkbenchRequest, { op: \"readdir\" }>,\n): Promise<void> {\n  try {\n    writeFrame(socket, { t: \"entries\", names: await readdir(req.path) });\n  } catch (err) {\n    sendError(socket, err);\n  }\n  socket.end();\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "10.13.13",
+  "version": "10.13.14",
   "description": "Conveyor Agent Runner v10 - PTY harness for the task chat (SDK harness for audit/project-chat). Agent-as-User architecture with BaseService patterns. Works locally too.",
   "keywords": [
     "agent",

package/runtime/entrypoint.sh

@@ -334,13 +334,6 @@ boot_mark "env injected — entering user-home wiring"
 
 export ANTHROPIC_API_KEY=$(echo "${BOOTSTRAP_JSON}" | jq -r '.anthropicKey // empty')
 export CLOUDSDK_AUTH_ACCESS_TOKEN=$(echo "${BOOTSTRAP_JSON}" | jq -r '.gcpToken // empty')
-# WorkPreservation GCS tier (spec §Durability & snapshots): the upload URL is
-# long-lived (used for the pod's whole lifetime of periodic captures + sleep
-# finalize); the download URL is present only when a snapshot exists and is
-# consumed once by restoreOnBoot.
-CONVEYOR_SNAPSHOT_UPLOAD_URL=$(echo "${BOOTSTRAP_JSON}" | jq -r '.snapshotUploadUrl // empty')
-CONVEYOR_SNAPSHOT_URL=$(echo "${BOOTSTRAP_JSON}" | jq -r '.snapshotUrl // empty')
-export CONVEYOR_SNAPSHOT_UPLOAD_URL CONVEYOR_SNAPSHOT_URL
 unset BOOTSTRAP_JSON
 # POD_BOOTSTRAP_TOKEN is deliberately NOT unset: it is the credential-refresh
 # key. The agent re-polls GET /api/v3/pods/bootstrap with it to swap in a
@@ -688,96 +681,29 @@ reset_tracked_repo_changes_before_assignment_checkout() {
 }
 
 # Shared by both the pod-image branch and the repo-present-non-pod-image branch
-# of prepare_workspace_git: refresh the remote token, fetch the base branch,
-# fetch/checkout the task branch (creating it from base if it doesn't exist on
-# origin yet), and merge latest base into it. On success the repo is left
-# checked out on the task branch, up to date with base. On any failure it
-# writes GIT_FAILED_MARKER and returns 1 — callers must not fall through to
-# `: > "$GIT_READY_MARKER"` in that case.
+# of prepare_workspace_git: refresh the remote token and warm origin/<base>.
+# The agent (ensureOnTaskBranch, Tasks 4-5) now owns the task-branch
+# fetch/checkout/create-from-base and the merge of base into the task branch —
+# this function no longer touches BRANCH or CHECKOUT_REF at all. On success the
+# repo is left on a clean tree with an up-to-date origin/<base> remote-tracking
+# ref. On any failure it writes GIT_FAILED_MARKER and returns 1 — callers must
+# not fall through to `: > "$GIT_READY_MARKER"` in that case.
 sync_task_branch_to_repo() {
   # Guarded so a set-url failure writes the failed marker instead of aborting
   # the backgrounded subshell (which would leave the agent waiting forever).
   if ! git -C repo remote set-url origin "https://x-access-token:${CONVEYOR_GITHUB_TOKEN}@github.com/${REPO_OWNER}/${REPO_NAME}.git" 2>/dev/null; then
-    echo "[pool] ERROR: remote set-url failed for pod-image repo" >&2
-    printf '%s' "pod-image remote set-url failed" > "$GIT_FAILED_MARKER"
+    echo "[pool] ERROR: remote set-url failed" >&2
+    printf '%s' "remote set-url failed" > "$GIT_FAILED_MARKER"
     return 1
   fi
-  # Always fetch latest base so downstream steps (and the agent's
-  # syncWithBaseBranch) have an up-to-date origin/<base> to merge from.
-  DEV_BRANCH="${BASE_BRANCH}"
-  if ! _fetch_dev_out=$(git -C repo fetch origin "+refs/heads/${DEV_BRANCH}:refs/remotes/origin/${DEV_BRANCH}" 2>&1); then
-    echo "[pool] WARN: fetch origin/${DEV_BRANCH} failed: ${_fetch_dev_out}" >&2
+  # Warm origin/<base> so the agent's checkout/fetch is a fast-forward.
+  if ! _fetch_out=$(git -C repo fetch origin "+refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}" 2>&1); then
+    echo "[pool] WARN: fetch origin/${BASE_BRANCH} failed: ${_fetch_out}" >&2
   fi
-
-  if ! reset_tracked_repo_changes_before_assignment_checkout; then
-    return 1
-  fi
-
-  if [ -n "${CHECKOUT_REF}" ]; then
-    echo "[pool] Fetching checkout ref ${CHECKOUT_REF} for review branch ${BRANCH}..."
-    if ! _fetch_checkout_out=$(git -C repo fetch origin "+${CHECKOUT_REF}:refs/remotes/origin/pr-checkout" 2>&1); then
-      echo "[pool] ERROR: Repo fetch failed for checkout ref '${CHECKOUT_REF}': ${_fetch_checkout_out}" >&2
-      printf '%s' "fetch checkout ref ${CHECKOUT_REF} failed" > "$GIT_FAILED_MARKER"
-      return 1
-    fi
-    if ! _checkout_out=$(git -C repo checkout -f -B "${BRANCH}" "refs/remotes/origin/pr-checkout" 2>&1); then
-      echo "[pool] ERROR: Repo checkout of ${CHECKOUT_REF} failed: ${_checkout_out}" >&2
-      printf '%s' "checkout of ${CHECKOUT_REF} failed" > "$GIT_FAILED_MARKER"
-      return 1
-    fi
-  else
-    # Fetch the task branch into a local ref explicitly so we can check it out.
-    # If the branch doesn't exist on origin, create it from the base branch.
-    # Note: if BRANCH equals DEV_BRANCH (deferred-branch case), the fetch above
-    # already populated the ref and this is a no-op.
-    if ! _fetch_out=$(git -C repo fetch origin "+refs/heads/${BRANCH}:refs/remotes/origin/${BRANCH}" 2>&1); then
-      # Check if the error is specifically due to the remote ref not existing
-      if echo "${_fetch_out}" | grep -q "couldn't find remote ref"; then
-        echo "[pool] Branch missing on origin — creating from base '${DEV_BRANCH}'"
-        # Create the branch locally from the base branch
-        if ! _create_out=$(git -C repo checkout -f -B "${BRANCH}" "origin/${DEV_BRANCH}" 2>&1); then
-          echo "[pool] ERROR: Failed to create branch '${BRANCH}' from '${DEV_BRANCH}': ${_create_out}" >&2
-          printf '%s' "create branch ${BRANCH} from ${DEV_BRANCH} failed" > "$GIT_FAILED_MARKER"
-          return 1
-        fi
-        # Push the new branch to origin with -u to set up tracking
-        if ! _push_out=$(git -C repo push -u origin "${BRANCH}" 2>&1); then
-          echo "[pool] ERROR: Failed to push new branch '${BRANCH}': ${_push_out}" >&2
-          printf '%s' "push new branch ${BRANCH} failed" > "$GIT_FAILED_MARKER"
-          return 1
-        fi
-        echo "[pool] Created and pushed new branch '${BRANCH}' from '${DEV_BRANCH}'"
-      else
-        # Other git error (auth, network, etc.) — fail loud as before
-        echo "[pool] ERROR: Repo fetch failed for branch '${BRANCH}': ${_fetch_out}" >&2
-        printf '%s' "fetch branch ${BRANCH} failed" > "$GIT_FAILED_MARKER"
-        return 1
-      fi
-    fi
-    # Use `checkout -B` to create or reset the local branch tracking origin.
-    # This leaves HEAD attached to a real branch (not detached) so `git status`,
-    # `git push`, and any tool that keys off branch state work correctly.
-    if ! _checkout_out=$(git -C repo checkout -f -B "${BRANCH}" "origin/${BRANCH}" 2>&1); then
-      echo "[pool] ERROR: Repo checkout of ${BRANCH} failed: ${_checkout_out}" >&2
-      printf '%s' "checkout of ${BRANCH} failed" > "$GIT_FAILED_MARKER"
-      return 1
-    fi
-  fi
-
-  # Merge latest dev into the task branch so the agent starts on up-to-date
-  # base code. Skip if the branch already contains origin/dev (fast-path)
-  # or if BRANCH is the dev branch itself.
-  if [ "${BRANCH}" != "${DEV_BRANCH}" ] && git -C repo rev-parse "origin/${DEV_BRANCH}" >/dev/null 2>&1; then
-    if git -C repo merge-base --is-ancestor "origin/${DEV_BRANCH}" HEAD; then
-      echo "[pool] Branch already up-to-date with origin/${DEV_BRANCH}"
-    elif ! _merge_out=$(git -C repo merge "origin/${DEV_BRANCH}" --no-edit 2>&1); then
-      echo "[pool] WARN: merge origin/${DEV_BRANCH} failed, aborting: ${_merge_out}" >&2
-      git -C repo merge --abort 2>/dev/null || true
-    else
-      echo "[pool] Merged origin/${DEV_BRANCH} into ${BRANCH}"
-    fi
-  fi
-  echo "[pool] Repo updated to ${BRANCH}@$(git -C repo rev-parse --short HEAD)"
+  # Leave the tree clean; the agent (ensureOnTaskBranch) does the authoritative
+  # checkout + conveyor-wip restore. No task-branch checkout, no dev merge here.
+  reset_tracked_repo_changes_before_assignment_checkout || return 1
+  echo "[pool] Repo remote ready; agent will checkout ${BRANCH}"
   return 0
 }
 
@@ -803,11 +729,10 @@ prepare_workspace_git() {
     mark_git_ready
   elif [ -d "repo/.git" ] && [ -n "${CONVEYOR_GITHUB_TOKEN}" ]; then
     # Non-image but repo already present (e.g. a baked image running without
-    # CONVEYOR_POD_IMAGE set). Must NOT settle for a bare remote-URL refresh —
-    # that would leave the agent running on whatever branch the repo snapshot
-    # happened to be on (e.g. dev), silently committing/pushing to the wrong
-    # branch. Run the exact same fetch/checkout/merge flow as the pod-image
-    # branch so this path ends up in the same checked-out-on-task-branch state.
+    # CONVEYOR_POD_IMAGE set). Run the exact same remote-refresh + base-warm
+    # flow as the pod-image branch so this path ends up in the same
+    # clean-tree, remote-ready state; the agent (ensureOnTaskBranch) does the
+    # actual task-branch checkout regardless of which branch got it here.
     echo "[pool] Repo present (non-pod-image) — updating repo to latest (branch=${BRANCH})..."
     if ! sync_task_branch_to_repo; then
       return 1
@@ -840,9 +765,10 @@ prepare_workspace_git() {
       # branch. A naive `clone --branch <task>` dies with "Remote branch not
       # found" when the task branch has never been pushed to origin, which
       # crash-loops the pod on every fresh task. sync_task_branch_to_repo below
-      # resolves/creates ${BRANCH} from the clone identically to the pod-image
-      # path. Full depth (no --depth 1) so its base-merge never hits "refusing
-      # to merge unrelated histories".
+      # only refreshes the remote and warms origin/<base> from this clone; the
+      # agent (ensureOnTaskBranch) resolves/creates ${BRANCH} from it. Full
+      # depth (no --depth 1) so the agent's base-merge never hits "refusing to
+      # merge unrelated histories".
       if ! _clone_out=$(git clone --single-branch --branch "${BASE_BRANCH}" \
           "https://x-access-token:${CONVEYOR_GITHUB_TOKEN}@github.com/${REPO_OWNER}/${REPO_NAME}.git" \
           repo 2>&1); then