@rallycry/conveyor-agent 10.13.12 → 10.13.14

package/dist/{chunk-4KIPA6LF.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";
@@ -2662,6 +2449,13 @@ var StartAdhocSessionRequestSchema = z4.object({
   mode: z4.enum(["adhoc", "pm"]).optional(),
   /** Base branch to check out (defaults to the project's dev branch). */
   branch: z4.string().max(300).optional(),
+  /**
+   * Server-assembled instructions the pod's TUI auto-submits once on first boot
+   * (headless kickoff). Used by the onboarding "Set it up for me" flow to seed a
+   * setup-driver prompt; the session stays watchable/interactive in the Sessions
+   * view. `ensureAdhocWorkspace` persists it and clears it after first submit.
+   */
+  initialPrompt: z4.string().max(2e4).optional(),
   requestingUserId: z4.string().optional()
 });
 var StopAdhocSessionRequestSchema = z4.object({
@@ -3299,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 {
@@ -3582,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;
   }
@@ -3845,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",
@@ -4021,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);
@@ -4140,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";
@@ -4331,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 };
 }
@@ -4407,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);
@@ -4458,13 +4252,29 @@ 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;
   }
 }
+function classifyTuiAuth(input) {
+  if (!input.isCloud) return "ready";
+  if (input.hasOauthToken || input.hasApiKey || input.credsHasAccessToken) return "ready";
+  return "no-credential";
+}
+async function resolveTuiAuthReadiness(env = process.env, readIdentity = readCredentialsIdentity) {
+  const isCloud = isConveyorCloudEnv(env);
+  const credsHasAccessToken = isCloud ? Boolean((await readIdentity())?.accessToken) : false;
+  const status = classifyTuiAuth({
+    isCloud,
+    hasOauthToken: Boolean(env.CLAUDE_CODE_OAUTH_TOKEN),
+    hasApiKey: Boolean(env.ANTHROPIC_API_KEY),
+    credsHasAccessToken
+  });
+  return { ready: status === "ready", status };
+}
 async function readCredentialsIdentity() {
   const parsed = parseClaudeAiOauth(await readRaw(claudeCredentialsPath()));
   if (!parsed) return null;
@@ -4486,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) {
@@ -4499,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);
@@ -4544,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) {
@@ -4560,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 : {};
@@ -4653,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;
@@ -4686,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)),
@@ -4695,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
 `
       );
     }
@@ -4717,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}
@@ -5030,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",
@@ -5067,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),
@@ -5122,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",
@@ -5149,6 +4959,39 @@ var PtySession = class {
   writeStdin(text) {
     this.pty?.write(text);
   }
+  /**
+   * Inject a follow-up message into the CURRENTLY-RUNNING turn by pasting it into
+   * the live TUI input, exactly as a human typing mid-turn would — the CLI queues
+   * it and picks it up at the next turn boundary. Unlike beginTurn this does NOT
+   * reset per-turn state, allocate a new queue, or re-arm the abort listener: the
+   * in-flight turn (and its transcript stream) keeps flowing, so the injected
+   * message and its response ride the SAME event pipeline. Returns false when
+   * there is no live, actively-draining turn to inject into — parked/idle
+   * (activeQueue === null), torn down, exited, or a raw-terminal TUI that gives
+   * us no trusted signal that a turn is running — so the caller falls back to the
+   * abort+respawn supersede path.
+   */
+  injectIntoRunningTurn(text) {
+    if (!this.pty || this._toreDown || this.exited) return false;
+    if (this.activeQueue === null) return false;
+    if (!this.adapter.capabilities.structuredEvents) return false;
+    if (!text.trim()) return false;
+    void this.submitLivePrompt(text);
+    return true;
+  }
+  /**
+   * Paste + submit a prompt into the live pty WITHOUT any turn bookkeeping.
+   * Mirrors deliverPrompt's submit path (bracketed paste, then a separate Enter
+   * after a settle window) but never arms the submit nudge — the running turn is
+   * already producing transcript records, so re-pressing Enter would risk
+   * accepting an unrelated mid-turn dialog. Fire-and-forget.
+   */
+  async submitLivePrompt(text) {
+    this.writeStdin(this.adapter.encodePromptBytes(text));
+    await sleep(resolveSubmitSettleMs());
+    if (this._toreDown || this.exited) return;
+    this.writeStdin("\r");
+  }
   /** Apply a relayed resize to the live pty (reconciled dims from the server). */
   resizePty(cols, rows) {
     if (cols <= 0 || rows <= 0) return;
@@ -5212,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 = "";
     }
   }
@@ -5488,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",
@@ -5504,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;
@@ -5523,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 };
   }
 }
@@ -5560,6 +5403,9 @@ var PtyHarness = class _PtyHarness {
   endedTimer = null;
   /** Passive-activity subscriber, re-attached to whichever session is parked. */
   passiveHandler = null;
+  /** Once-per-session guard so the "no Claude credential" notice isn't re-posted
+   *  on every respawn (a fresh spawn happens on each fingerprint/lineage flip). */
+  authNoticeSent = false;
   /**
    * Wiggle the live pty's size so the CLI repaints its whole screen. No-op on
    * the SDK harness. Falls back to the parked session so an API reconnect while
@@ -5568,6 +5414,30 @@ var PtyHarness = class _PtyHarness {
   forceRepaint() {
     (this.activeSession ?? this.parked)?.forceRepaint();
   }
+  /** Actionable message posted to the card when a spawn will park at the Claude
+   *  sign-in screen. Kept as a constant so the harness stays free of i18n deps. */
+  static AUTH_NOT_READY_MESSAGE = "\u26A0\uFE0F This pod started the Claude Code TUI with no Claude credential, so it is parked on the sign-in screen and can't make progress. This usually means there is no usable Claude subscription token or API key configured for this project/assignee. Add or repair the Claude credential in project settings, then restart the session.";
+  /**
+   * Best-effort: if the TUI is about to spawn with no usable credential, post a
+   * one-time diagnostic through the relay bridge. Never throws — a readiness
+   * probe must not block or fail a spawn.
+   */
+  async warnIfAuthNotReady() {
+    if (this.authNoticeSent || !this.bridge?.notifyAuthNotReady) return;
+    try {
+      const readiness = await resolveTuiAuthReadiness();
+      if (readiness.ready) return;
+      this.authNoticeSent = true;
+      this.bridge.notifyAuthNotReady(_PtyHarness.AUTH_NOT_READY_MESSAGE);
+      _PtyHarness.log.warn(
+        "Claude TUI spawning with no usable credential \u2014 parked at sign-in screen"
+      );
+    } catch (err) {
+      _PtyHarness.log.warn("auth-readiness probe failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   async *executeQuery(opts) {
     const want = opts.resume ?? opts.options.resume;
     const fingerprint = this.fingerprintOf(opts.options);
@@ -5589,6 +5459,9 @@ var PtyHarness = class _PtyHarness {
         await ensureUsableClaudeConfigHome(opts.options.cwd, _PtyHarness.log);
       }
       await this.adapter.prepareEnvironment({ cwd: opts.options.cwd });
+      if (this.adapter.capabilities.structuredEvents) {
+        await this.warnIfAuthNotReady();
+      }
       session.onExit(() => this.handleSessionExit(session));
       await session.start();
     }
@@ -5599,6 +5472,15 @@ var PtyHarness = class _PtyHarness {
    * query running" (a human typed into the idle Connected-TUI). Attaches to the
    * currently-parked session and to any session parked later.
    */
+  /**
+   * PTY-only: inject a follow-up message into the turn currently streaming
+   * events (the active session), so the runner can add to a running turn without
+   * aborting + respawning. Returns false when no turn is active (idle/parked) or
+   * the paste couldn't be delivered — the caller supersedes instead.
+   */
+  injectIntoRunningTurn(text) {
+    return this.activeSession?.injectIntoRunningTurn(text) ?? false;
+  }
   onPassiveActivity(handler) {
     this.passiveHandler = handler;
     const unsubParked = this.parked?.onPassiveActivity(handler);
@@ -5971,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(),
@@ -5996,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
@@ -6368,16 +6250,30 @@ 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.`
   ];
 }
+function buildNoPrWhenNoCodeSection(baseBranch) {
+  const base = baseBranch ?? "dev";
+  return [
+    ``,
+    `### A PR is NOT required \u2014 only open one for actual code changes`,
+    `\`create_pull_request\` is for tasks that change code in the repo. Many tasks don't: support requests, config/credential help, answering a question, investigations, or research whose deliverable is an answer or a file rather than a diff.`,
+    `- If you finish the work with NO code changes (an empty \`git diff ${base}..HEAD\`), do NOT open a PR. An empty or throwaway PR just to "complete" the workflow is wrong \u2014 a human then has to close it.`,
+    `- Deliver the result where it belongs: post the answer/config/findings with \`post_to_chat\`, and attach any files the user should keep with \`upload_attachment\`.`,
+    `- Then complete the card directly with \`force_update_task_status("Complete")\` \u2014 there is no PR or review step for a no-code task.`,
+    `- When in doubt, check \`git diff ${base}..HEAD\`: a real diff means open a PR; no diff means finish in chat and mark Complete.`
+  ];
+}
 function buildExplorationMethodology() {
   return [
     ``,
@@ -6500,7 +6396,7 @@ function buildAutoPrompt(context, runnerMode) {
       `If no children exist yet, break the work down now: save a parent-level plan with update_task_plan, then create child tasks with create_subtask (each with a detailed plan).`,
       `Child task status lifecycle: Open \u2192 InProgress \u2192 ReviewPR \u2192 ReviewDev \u2192 Complete.`,
       `Set child ordering with \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` \u2014 explicit metadata the pack runner schedules off, not order described in plan text. Independent children get none and run in parallel.`
-    ] : [],
+    ] : buildNoPrWhenNoCodeSection(context?.baseBranch),
     ``,
     `### Autonomous Guidelines:`,
     `- Make decisions independently \u2014 do not ask the team for approval at each step`,
@@ -6510,37 +6406,40 @@ function buildAutoPrompt(context, runnerMode) {
   if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
   return parts.join("\n");
 }
+function buildBuildingPrompt(context) {
+  const parts = [
+    `
+## Mode: Building`,
+    `You are in Building mode \u2014 executing the plan.`,
+    `- You have full coding access (read, write, edit, bash, git)`,
+    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
+    ...context?.isParentTask ? [
+      `- You are a parent task. Use \`list_subtasks\`, \`start_child_cloud_build\`, and subtask management tools to coordinate children.`,
+      `- Do NOT implement code directly \u2014 fire child builds and review their work.`,
+      `- Goal: coordinate child task execution and ensure all children complete successfully`
+    ] : [
+      `- If this is a leaf task (no children): execute the plan directly`,
+      `- Goal: implement the plan, run scoped verification, open a PR when done`,
+      ``,
+      `### Pre-PR Verification Checklist`,
+      `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Before calling \`mcp__conveyor__create_pull_request\`, scope verification to your diff:`,
+      `1. \`bun run check\` \u2014 lint + typecheck (fast; run whenever you changed code)`,
+      `2. \`bun run test:affected\` \u2014 runs only the tests your diff can affect (docs-only diffs run nothing; apps/api diffs run unit tests only since CI covers the int shards; shared/db diffs escalate to the full suite automatically)`,
+      `Docs/markdown/.claude-only changes need NO local gates \u2014 open the PR and let CI validate.`,
+      `If a gate fails, fix it before opening the PR. Do NOT open PRs with known failing gates. Never run the full \`bun run test\` for a diff confined to one package.`,
+      `For refactors: also run \`git diff ${context?.baseBranch ?? "dev"}..HEAD\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`,
+      ...buildNoPrWhenNoCodeSection(context?.baseBranch),
+      ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
+    ]
+  ];
+  return parts.join("\n");
+}
 function buildModePrompt(agentMode, context, runnerMode) {
   switch (agentMode) {
     case "discovery":
       return buildDiscoveryPrompt(context, runnerMode);
-    case "building": {
-      const parts = [
-        `
-## Mode: Building`,
-        `You are in Building mode \u2014 executing the plan.`,
-        `- You have full coding access (read, write, edit, bash, git)`,
-        `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
-        ...context?.isParentTask ? [
-          `- You are a parent task. Use \`list_subtasks\`, \`start_child_cloud_build\`, and subtask management tools to coordinate children.`,
-          `- Do NOT implement code directly \u2014 fire child builds and review their work.`,
-          `- Goal: coordinate child task execution and ensure all children complete successfully`
-        ] : [
-          `- If this is a leaf task (no children): execute the plan directly`,
-          `- Goal: implement the plan, run scoped verification, open a PR when done`,
-          ``,
-          `### Pre-PR Verification Checklist`,
-          `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Before calling \`mcp__conveyor__create_pull_request\`, scope verification to your diff:`,
-          `1. \`bun run check\` \u2014 lint + typecheck (fast; run whenever you changed code)`,
-          `2. \`bun run test:affected\` \u2014 runs only the tests your diff can affect (docs-only diffs run nothing; apps/api diffs run unit tests only since CI covers the int shards; shared/db diffs escalate to the full suite automatically)`,
-          `Docs/markdown/.claude-only changes need NO local gates \u2014 open the PR and let CI validate.`,
-          `If a gate fails, fix it before opening the PR. Do NOT open PRs with known failing gates. Never run the full \`bun run test\` for a diff confined to one package.`,
-          `For refactors: also run \`git diff ${context?.baseBranch ?? "dev"}..HEAD\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`,
-          ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
-        ]
-      ];
-      return parts.join("\n");
-    }
+    case "building":
+      return buildBuildingPrompt(context);
     case "review":
       return buildReviewPrompt(context);
     case "auto":
@@ -7005,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(
@@ -7017,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.`
     );
   }
@@ -7758,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",
@@ -7775,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(
@@ -8539,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);
@@ -8548,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;
@@ -8563,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;
@@ -9427,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")) {
@@ -9449,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;
@@ -10002,6 +9902,7 @@ function buildPtyBridge(connection) {
     sendOutput: (data, dims) => connection.sendPtyOutput(data, dims),
     sendChatEvent: (event) => connection.sendPtyChatEvent(event),
     sendEnded: () => connection.sendPtyEnded(),
+    notifyAuthNotReady: (detail) => connection.postChatMessage(detail),
     onInput: (handler) => connection.onPtyInput(handler),
     onResize: (handler) => connection.onPtyResize(handler)
   };
@@ -10072,6 +9973,16 @@ var QueryBridge = class {
   resume() {
     this._stopped = false;
   }
+  /**
+   * Inject a follow-up message into the turn currently running under the harness
+   * (PTY keep-alive) instead of aborting it. Returns true when the harness fed
+   * the message into the live TUI; false when there is no running turn to inject
+   * into or the harness has no live terminal (SDK) — the caller then supersedes
+   * via stop() + respawn.
+   */
+  injectIntoRunningTurn(content) {
+    return this.harness.injectIntoRunningTurn?.(content) ?? false;
+  }
   /**
    * Tear down any parked/active CLI process the harness is keeping alive between
    * turns (PTY keep-alive). Called by SessionRunner on stop/shutdown so the
@@ -10249,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 [];
@@ -10278,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 {
       }
@@ -10581,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;
@@ -10699,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 {
@@ -10928,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";
@@ -10944,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 {
@@ -10989,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;
@@ -11035,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.
@@ -11112,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);
@@ -11179,6 +11090,7 @@ var SessionRunner = class _SessionRunner {
 `
       );
     }
+    this.workspaceCommands?.notifyLoopReady();
     while (!this.stopped) {
       if (this._state !== "idle") await this.setState("idle");
       await this.coreLoop();
@@ -11248,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");
@@ -11274,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());
@@ -11427,13 +11341,36 @@ var SessionRunner = class _SessionRunner {
       const resolve = this.inputResolver;
       this.inputResolver = null;
       resolve(msg);
-    } else {
-      this.pendingMessages.push(msg);
-      if (this._state === "running" || this._state === "waiting_for_input") {
-        this.queryBridge?.stop();
-      }
+      return;
+    }
+    if (this._state === "running" && this.canInjectIntoRunningTurn(msg) && this.queryBridge?.injectIntoRunningTurn(msg.content)) {
+      void this.callbacks.onEvent({
+        type: "user_message",
+        content: msg.content,
+        userId: msg.userId
+      });
+      return;
+    }
+    this.pendingMessages.push(msg);
+    if (this._state === "running" || this._state === "waiting_for_input") {
+      this.queryBridge?.stop();
     }
   }
+  /**
+   * Whether a mid-turn message may be pasted into the live running TUI rather
+   * than superseding the turn. Restricted to genuine same-mode user follow-ups:
+   * a pending mode restart, an empty body, a prefill hint, or any non-"user"
+   * source (mode_change / pty_passive / system / ci_failure / review_trigger)
+   * must take the abort+respawn path — a mode/fingerprint change needs a fresh
+   * spawn, and a prefill must park unsubmitted for the human.
+   */
+  canInjectIntoRunningTurn(msg) {
+    if (this.mode.pendingModeRestart) return false;
+    if (!msg.content.trim()) return false;
+    if (msg.delivery === "prefill") return false;
+    if (msg.source && msg.source !== "user") return false;
+    return true;
+  }
   // ── Query execution with abort handling ────────────────────────────
   /** Run queryBridge.execute, swallowing abort errors from stop/softStop. */
   async executeQuery(followUpContent, promptDelivery) {
@@ -11470,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
@@ -11488,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(
@@ -11505,7 +11463,6 @@ var SessionRunner = class _SessionRunner {
 `
         );
       }
-      await this.uploadGcsSnapshotIfConfigured();
     } catch {
     } finally {
       this.periodicFlushInFlight = false;
@@ -11531,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. */
@@ -11571,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}
@@ -11719,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() {
@@ -11845,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)
@@ -11938,16 +11847,10 @@ export {
   sampleKeyUsage,
   awaitGitReady,
   PortDiscovery,
-  uploadSnapshotToGcs,
-  captureSnapshot,
-  startPeriodic,
-  stop,
-  finalizeForSleep,
-  restoreOnBoot,
   SessionRunner,
   loadForwardPorts,
   buildSessionPreviewPorts,
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-4KIPA6LF.js.map
+//# sourceMappingURL=chunk-J4UH5TOO.js.map