@rallycry/conveyor-agent 10.13.8 → 10.13.10

package/dist/{chunk-AJZIO5QI.js → chunk-UVR5XFE4.js}

@@ -1,13 +1,31 @@
 import {
   LoopLagMonitor
 } from "./chunk-7TQO4ZF4.js";
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
+import {
+  getWorkbenchClient
+} from "./chunk-YRC57EYG.js";
+import {
+  workbenchEnabled
+} from "./chunk-4VUQ2NPF.js";
+import {
+  MAX_BETWEEN_TURN_BUFFER,
+  MAX_DIAGNOSTIC_OUTPUT,
+  buildPromptBytes,
+  buildSnapshotTar,
+  extractSnapshotTar,
+  inheritedEnv,
+  loadPtySpawn,
+  parseUserQuestions,
+  renderPromptContentText,
+  resolvePlanDialogTiming,
+  resolvePtySpawn,
+  resolveSubmitNudgeTiming,
+  resolveSubmitSettleMs,
+  sessionTempBase,
+  sleep,
+  transcriptSize,
+  turnOptionsFrom
+} from "./chunk-2K6RRTQC.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -1193,6 +1211,14 @@ var GIT_TIMEOUT_MS = 6e4;
 var GIT_SLOW_TIMEOUT_MS = 12e4;
 var GIT_MAX_BUFFER = 16 * 1024 * 1024;
 async function git(cwd, args, timeoutMs = GIT_TIMEOUT_MS) {
+  if (workbenchEnabled()) {
+    const { stdout: stdout2 } = await getWorkbenchClient().execFile("git", args, {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer: GIT_MAX_BUFFER
+    });
+    return stdout2.trim();
+  }
   const { stdout } = await execFileAsync("git", args, {
     cwd,
     timeout: timeoutMs,
@@ -1574,7 +1600,9 @@ async function backupOtherBranches(cwd, currentBranch) {
 }
 
 // src/runner/work-preservation/index.ts
-import { rm as rm3 } from "fs/promises";
+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) {
@@ -1583,193 +1611,19 @@ function selectRestoreSource(probe) {
   return "clean";
 }
 
-// src/runner/work-preservation/snapshot-tar.ts
-import { execFile as execFile2 } from "child_process";
+// src/runner/work-preservation/snapshot-transfer.ts
+import { randomUUID } from "crypto";
 import { createReadStream, createWriteStream } from "fs";
-import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+import { rm } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
-import { pipeline } from "stream/promises";
-import { promisify as promisify2 } from "util";
-import { createGzip } from "zlib";
-import * as tar from "tar";
-
-// src/runner/work-preservation/snapshot-artifact.ts
-function planSnapshotFiles(git2) {
-  const include = git2.trackedAndUntracked();
-  const includeSet = new Set(include);
-  const deletions = [...new Set(git2.deletedSinceHead())].filter((path4) => !includeSet.has(path4));
-  return { include, deletions };
-}
-
-// src/runner/work-preservation/snapshot-tar.ts
-var SNAPSHOT_MANIFEST_NAME = ".conveyor-snapshot-manifest.json";
-var LEGACY_PG_DUMP_FILENAME = ".conveyor-pgdump.sql";
-var STATUS_MAX_BUFFER = 64 * 1024 * 1024;
-function parseStatusPorcelainZ(raw) {
-  const includes = [];
-  const deletions = [];
-  const tokens = raw.split("\0");
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!token || token.length < 4) continue;
-    const x = token[0];
-    const y = token[1];
-    const filePath = token.slice(3);
-    if (x === "R" || x === "C") {
-      const origPath = tokens[++i];
-      if (x === "R" && origPath) deletions.push(origPath);
-    }
-    if (x === "!") continue;
-    const missingFromWorktree = y === "D" || x === "D" && y === " ";
-    if (missingFromWorktree) deletions.push(filePath);
-    else includes.push(filePath);
-  }
-  return { includes, deletions };
-}
-var execFileAsync2 = promisify2(execFile2);
-var GIT_TIMEOUT_MS2 = 12e4;
-async function realGitSurface(cwd) {
-  const { stdout } = await execFileAsync2("git", ["status", "--porcelain=v1", "-z", "-uall"], {
-    cwd,
-    timeout: GIT_TIMEOUT_MS2,
-    maxBuffer: STATUS_MAX_BUFFER
-  });
-  const cached = parseStatusPorcelainZ(stdout.toString());
-  return {
-    trackedAndUntracked: () => cached.includes,
-    deletedSinceHead: () => cached.deletions
-  };
-}
-async function gitHead(cwd) {
-  try {
-    const { stdout } = await execFileAsync2("git", ["rev-parse", "HEAD"], {
-      cwd,
-      timeout: GIT_TIMEOUT_MS2
-    });
-    return stdout.toString().trim() || null;
-  } catch {
-    return null;
-  }
-}
-async function buildSnapshotTar(cwd) {
-  const staging = await mkdtemp(path.join(tmpdir(), "conveyor-snapshot-"));
-  const cleanup = async () => {
-    await rm(staging, { recursive: true, force: true }).catch(() => {
-    });
-  };
-  try {
-    const plan = planSnapshotFiles(await realGitSurface(cwd));
-    const head = await gitHead(cwd);
-    if (!head) throw new Error("cannot snapshot a repo without a resolvable HEAD");
-    const capturedAt = Date.now();
-    const manifest = {
-      head,
-      deletions: plan.deletions,
-      capturedAt
-    };
-    await writeFile(path.join(staging, SNAPSHOT_MANIFEST_NAME), JSON.stringify(manifest), "utf8");
-    const stagedEntries = [SNAPSHOT_MANIFEST_NAME];
-    const rawTarPath = path.join(staging, "snapshot.tar");
-    await tar.create({ cwd: staging, file: rawTarPath, portable: true }, stagedEntries);
-    if (plan.include.length > 0) {
-      await tar.replace({ file: rawTarPath, cwd, portable: true }, plan.include);
-    }
-    const tarPath = path.join(staging, "snapshot.tar.gz");
-    await pipeline(createReadStream(rawTarPath), createGzip(), createWriteStream(tarPath));
-    await rm(rawTarPath, { force: true });
-    const { size } = await stat(tarPath);
-    return {
-      tarPath,
-      sizeBytes: size,
-      fileCount: plan.include.length,
-      deletionCount: plan.deletions.length,
-      capturedAt,
-      cleanup
-    };
-  } catch (err) {
-    await cleanup();
-    throw err;
-  }
-}
-function isWithinWorkspace(cwd, rel) {
-  if (!rel || path.isAbsolute(rel)) return false;
-  const root = path.resolve(cwd);
-  const abs = path.resolve(root, rel);
-  return abs !== root && abs.startsWith(root + path.sep);
-}
-async function readSnapshotArchive(tarPath) {
-  let manifestRaw = null;
-  try {
-    await tar.list({
-      file: tarPath,
-      onReadEntry: (entry) => {
-        if (entry.path === SNAPSHOT_MANIFEST_NAME) {
-          const chunks = [];
-          entry.on("data", (chunk) => chunks.push(chunk));
-          entry.on("end", () => {
-            manifestRaw = Buffer.concat(chunks);
-          });
-        }
-      }
-    });
-  } catch {
-    return null;
-  }
-  if (!manifestRaw) return null;
-  try {
-    const parsed = JSON.parse(manifestRaw.toString("utf8"));
-    if (typeof parsed.head !== "string" || !parsed.head) return null;
-    return {
-      head: parsed.head,
-      deletions: Array.isArray(parsed.deletions) ? parsed.deletions : [],
-      capturedAt: typeof parsed.capturedAt === "number" ? parsed.capturedAt : 0
-    };
-  } catch {
-    return null;
-  }
-}
-async function extractSnapshotTar(cwd, tarPath) {
-  const manifest = await readSnapshotArchive(tarPath);
-  if (!manifest) return { status: "invalid" };
-  const currentHead = await gitHead(cwd);
-  if (manifest.head !== currentHead) {
-    return { status: "stale-head", snapshotHead: manifest.head, currentHead };
-  }
-  let filesExtracted = 0;
-  await tar.extract({
-    file: tarPath,
-    cwd,
-    filter: (entryPath) => {
-      if (entryPath === SNAPSHOT_MANIFEST_NAME || entryPath === LEGACY_PG_DUMP_FILENAME) {
-        return false;
-      }
-      filesExtracted++;
-      return true;
-    }
-  });
-  let deletionsApplied = 0;
-  for (const rel of manifest.deletions) {
-    if (typeof rel !== "string" || !isWithinWorkspace(cwd, rel)) continue;
-    await rm(path.resolve(cwd, rel), { recursive: true, force: true });
-    deletionsApplied++;
-  }
-  return { status: "extracted", filesExtracted, deletionsApplied };
-}
-
-// src/runner/work-preservation/snapshot-transfer.ts
-import { randomUUID } from "crypto";
-import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "fs";
-import { rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import path2 from "path";
 import { Readable } from "stream";
-import { pipeline as pipeline2 } from "stream/promises";
+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(createReadStream2(tarResult.tarPath));
+    const body = Readable.toWeb(createReadStream(tarResult.tarPath));
     const res = await fetch(url, {
       method: "PUT",
       headers: {
@@ -1787,26 +1641,51 @@ async function putSnapshotToGcs(url, tarResult) {
   }
 }
 async function downloadSnapshotToTemp(url) {
-  const tmpTar = path2.join(tmpdir2(), `conveyor-snapshot-restore-${randomUUID()}.tar.gz`);
+  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 pipeline2(
+    await pipeline(
       Readable.fromWeb(res.body),
-      createWriteStream2(tmpTar)
+      createWriteStream(tmpTar)
     );
     return tmpTar;
   } catch {
-    await rm2(tmpTar, { force: true }).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;
@@ -1819,7 +1698,7 @@ var EMPTY_GCS_RESULT = {
 async function doUploadSnapshotToGcs(cwd, uploadUrl, opts) {
   let tarResult;
   try {
-    tarResult = await buildSnapshotTar(cwd);
+    tarResult = await captureSnapshotTar(cwd);
   } catch {
     return EMPTY_GCS_RESULT;
   }
@@ -1902,7 +1781,7 @@ async function restoreOnBoot(bundle, cwd) {
     const tmpTar = await downloadSnapshotToTemp(bundle.snapshotUrl);
     if (tmpTar) {
       try {
-        const result = await extractSnapshotTar(cwd, tmpTar);
+        const result = await applySnapshotTar(cwd, tmpTar);
         if (result.status === "extracted") {
           gcsAvailable = true;
           gcsFileCount = result.filesExtracted;
@@ -1910,7 +1789,7 @@ async function restoreOnBoot(bundle, cwd) {
       } catch {
         gcsAvailable = false;
       } finally {
-        await rm3(tmpTar, { force: true }).catch(() => {
+        await rm2(tmpTar, { force: true }).catch(() => {
         });
       }
     }
@@ -2318,7 +2197,10 @@ var UpdateTaskPropertiesRequestSchema = z3.object({
   tagIds: z3.array(z3.string()).optional(),
   tagNames: z3.array(z3.string()).optional(),
   githubPRUrl: z3.string().url().optional(),
-  githubBranch: z3.string().optional()
+  githubBranch: z3.string().optional(),
+  // Canonical risk level, or null to clear — same semantics as the headless
+  // update_task boundary (resolved to the project's Risk row in the handler).
+  risk: riskLevelSchema.nullable().optional()
 });
 var ListIconsRequestSchema = z3.object({
   sessionId: z3.string()
@@ -2633,6 +2515,9 @@ var GetProjectSummaryRequestSchema = z4.object({
 var GetProjectOnboardingStatusRequestSchema = z4.object({
   projectId: z4.string()
 });
+var GetProjectOnboardingStepRequestSchema = z4.object({
+  projectId: z4.string()
+});
 var GetProjectConnectUrlsRequestSchema = z4.object({
   projectId: z4.string()
 });
@@ -2650,7 +2535,13 @@ var UpdateProjectTaskRequestSchema = z4.object({
   projectId: z4.string(),
   taskId: z4.string(),
   title: z4.string().optional(),
+  description: z4.string().optional(),
   plan: z4.string().optional(),
+  // Enum validation lives at the MCP tool layer (mirrors createProjectTask);
+  // the handler routes through the shared updateStatus core (InProgress
+  // dependency check + cleanup/board/Slack side effects), not the stricter
+  // card-type-validating path the Socket.IO updateTaskStatus mutation uses.
+  status: z4.string().optional(),
   // Canonical risk level, or null to clear. Resolved to the project's
   // configured Risk row (by rank) in the handler.
   risk: riskLevelSchema.nullable().optional(),
@@ -2660,9 +2551,9 @@ var UpdateProjectTaskRequestSchema = z4.object({
   subProjectId: z4.string().nullable().optional(),
   requestingUserId: z4.string().optional()
 }).strict().refine(
-  (v) => v.title !== void 0 || v.plan !== void 0 || v.risk !== void 0 || v.assignedUserId !== void 0 || v.subProjectId !== void 0,
+  (v) => v.title !== void 0 || v.description !== void 0 || v.plan !== void 0 || v.status !== void 0 || v.risk !== void 0 || v.assignedUserId !== void 0 || v.subProjectId !== void 0,
   {
-    message: "update_task requires at least one field to change (title, plan, risk, assignedUserId, or subProjectId)"
+    message: "update_task requires at least one field to change (title, description, plan, status, risk, assignedUserId, or subProjectId)"
   }
 );
 var TransitionProjectTaskStatusRequestSchema = z4.object({
@@ -2814,6 +2705,9 @@ var UpdateProjectSubtaskRequestSchema = z4.object({
   ordinal: z4.number().int().nonnegative().optional(),
   storyPointValue: z4.number().int().positive().optional(),
   followParentStatus: z4.boolean().optional(),
+  /** Replace-set of sibling subtask ids/slugs this subtask blocks on ([] clears).
+   * Mirrors the in-pod updateSubtask semantics. */
+  dependsOn: z4.array(z4.string().min(1)).max(32).optional(),
   requestingUserId: z4.string().optional()
 });
 var DeleteProjectSubtaskRequestSchema = z4.object({
@@ -3389,9 +3283,9 @@ var ClaudeCodeHarness = class {
 };
 
 // src/harness/pty/session.ts
-import { mkdtemp as mkdtemp2, mkdir as mkdir3, rm as rm5 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join4, dirname } from "path";
+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";
 
 // src/harness/pty/event-queue.ts
 var AsyncEventQueue = class {
@@ -3672,8 +3566,8 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path4, onEvent, onRawRecord) {
-    this.path = path4;
+  constructor(path3, onEvent, onRawRecord) {
+    this.path = path3;
     this.onEvent = onEvent;
     this.onRawRecord = onRawRecord;
   }
@@ -3807,6 +3701,27 @@ function stringField2(record, ...keys) {
 function truncate(text, max) {
   return text.length > max ? `${text.slice(0, max)}\u2026` : text;
 }
+function compactQuestionsJson(questions) {
+  const serialize = (qs) => JSON.stringify({ questions: qs });
+  const withDescriptions = (max) => questions.map((q) => ({
+    ...q,
+    options: q.options.map((o) => ({ ...o, description: truncate(o.description, max) }))
+  }));
+  const full = serialize(questions);
+  if (full.length <= TOOL_INPUT_MAX) return full;
+  const shortened = serialize(withDescriptions(80));
+  if (shortened.length <= TOOL_INPUT_MAX) return shortened;
+  const bare = serialize(withDescriptions(0));
+  if (bare.length <= TOOL_INPUT_MAX) return bare;
+  return bare.slice(0, TOOL_INPUT_MAX);
+}
+function compactToolInput(name, input) {
+  if (name === "AskUserQuestion" && isRecord2(input)) {
+    const questions = parseUserQuestions(input);
+    if (questions.length > 0) return compactQuestionsJson(questions);
+  }
+  return JSON.stringify(input ?? {}).slice(0, TOOL_INPUT_MAX);
+}
 function isNonConversationText(text) {
   const trimmed = text.trimStart();
   return trimmed.startsWith("<command-name>") || trimmed.startsWith("<local-command-") || trimmed.startsWith("<task-notification>");
@@ -3843,7 +3758,7 @@ function mapAssistant2(record) {
         const event = {
           kind: "tool_use",
           name: truncate(name, 200),
-          input: JSON.stringify(input ?? {}).slice(0, TOOL_INPUT_MAX)
+          input: compactToolInput(name, input)
         };
         const id = stringField2(raw, "id");
         if (id !== void 0) event.id = id;
@@ -3912,17 +3827,17 @@ function mapChatRecords(raw) {
 }
 
 // src/harness/pty/settings.ts
-import { mkdir, writeFile as writeFile2, chmod } from "fs/promises";
+import { mkdir, writeFile, chmod } from "fs/promises";
 import { homedir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 function claudeConfigHome() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join2(homedir(), ".claude");
 }
 function projectSlug(cwd) {
   return cwd.replace(/\//g, "-");
 }
 function sessionTranscriptPath(cwd, sessionId) {
-  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
+  return join2(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
 }
 var ALLOW_RULES = [
   "Bash",
@@ -4090,10 +4005,10 @@ function preToolUse(payload) {
 }
 `;
 async function writeHookSettings(dir) {
-  const helperPath = join(dir, "hook-helper.cjs");
-  const settingsPath = join(dir, "settings.json");
+  const helperPath = join2(dir, "hook-helper.cjs");
+  const settingsPath = join2(dir, "settings.json");
   await mkdir(dir, { recursive: true });
-  await writeFile2(helperPath, HOOK_HELPER_SOURCE, "utf8");
+  await writeFile(helperPath, HOOK_HELPER_SOURCE, "utf8");
   await chmod(helperPath, 493);
   const settings = {
     // Pre-accept Claude Code's "Bypass Permissions mode" disclaimer. Build-capable
@@ -4149,7 +4064,7 @@ async function writeHookSettings(dir) {
       ]
     }
   };
-  await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
   return { settingsPath, helperPath };
 }
 
@@ -4208,8 +4123,8 @@ var PtyOutputCoalescer = class {
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
 import { z as z6 } from "zod";
-import { writeFile as writeFile3 } from "fs/promises";
-import { join as join2 } from "path";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -4400,8 +4315,8 @@ 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 = join2(tempDir, "mcp-config.json");
-  await writeFile3(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
+  const mcpConfigPath = join3(tempDir, "mcp-config.json");
+  await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
   return { servers, mcpConfigPath };
 }
 
@@ -4476,13 +4391,13 @@ ${tail}`);
 }
 
 // src/harness/pty/credentials.ts
-import { chmod as chmod2, mkdir as mkdir2, readFile, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
 var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
 function claudeCredentialsPath() {
-  return join3(claudeConfigHome(), ".credentials.json");
+  return join4(claudeConfigHome(), ".credentials.json");
 }
 function isConveyorCloudEnv(env = process.env) {
   return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
@@ -4527,9 +4442,9 @@ function planCredentialsWrite(input) {
   if (fresh) return { action: "skip", reason: "current" };
   return { action: "write", contents };
 }
-async function readRaw(path4) {
+async function readRaw(path3) {
   try {
-    return await readFile(path4, "utf8");
+    return await readFile(path3, "utf8");
   } catch {
     return null;
   }
@@ -4555,10 +4470,10 @@ async function writeWithReadBackRetry(io2, contents, delaysMs = READ_BACK_DELAYS
     await sleep2(delaysMs[attempt]);
   }
 }
-function fsWriteIo(path4, mode) {
+function fsWriteIo(path3, mode) {
   return {
-    write: (contents) => writeFile4(path4, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
-    read: () => readRaw(path4)
+    write: (contents) => writeFile3(path3, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
+    read: () => readRaw(path3)
   };
 }
 async function ensureClaudeCredentials(env = process.env) {
@@ -4568,23 +4483,23 @@ async function ensureClaudeCredentials(env = process.env) {
     await sanitizeApprovedApiKeys(token);
   }
   try {
-    const path4 = claudeCredentialsPath();
+    const path3 = claudeCredentialsPath();
     const plan = planCredentialsWrite({
       isCloud,
       token,
-      existingRaw: await readRaw(path4),
+      existingRaw: await readRaw(path3),
       now: Date.now()
     });
     if (plan.action === "skip") return;
     await mkdir2(claudeConfigHome(), { recursive: true });
-    const verified = await writeWithReadBackRetry(fsWriteIo(path4, 384), plan.contents);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path3, 384), plan.contents);
     if (!verified) {
       process.stderr.write(
-        `[conveyor-agent] claude credentials read-back still stale after retries at ${path4} \u2014 TUI may land on the login picker
+        `[conveyor-agent] claude credentials read-back still stale after retries at ${path3} \u2014 TUI may land on the login picker
 `
       );
     }
-    await chmod2(path4, 384).catch(() => {
+    await chmod2(path3, 384).catch(() => {
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -4613,12 +4528,12 @@ function planApprovedApiKeyCleanup(existingRaw, oauthToken) {
 }
 async function sanitizeApprovedApiKeys(oauthToken) {
   try {
-    const path4 = claudeJsonPath();
-    const cleaned = planApprovedApiKeyCleanup(await readRaw(path4), oauthToken);
+    const path3 = claudeJsonPath();
+    const cleaned = planApprovedApiKeyCleanup(await readRaw(path3), oauthToken);
     if (cleaned === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path4), cleaned);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path3), 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 ${path4} \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 ${path3} \u2014 CLI may still see the poisoned entry
 `
     );
   } catch (err) {
@@ -4629,7 +4544,7 @@ async function sanitizeApprovedApiKeys(oauthToken) {
 }
 function claudeJsonPath() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join3(configDir, ".claude.json") : join3(homedir2(), ".claude.json");
+  return configDir ? join4(configDir, ".claude.json") : join4(homedir2(), ".claude.json");
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -4722,7 +4637,7 @@ function planClaudeJsonSeed(existingRaw, trustCwd, oauthIdentity) {
   return changed ? JSON.stringify(config) : null;
 }
 function conveyorOauthMarkerPath() {
-  return join3(claudeConfigHome(), "conveyor-oauth-account.json");
+  return join4(claudeConfigHome(), "conveyor-oauth-account.json");
 }
 function parseOauthIdentity(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -4755,8 +4670,8 @@ async function persistOauthIdentityMarker(configIdentity, markerIdentity) {
 async function ensureClaudeOnboarding(env = process.env, trustCwd) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path4 = claudeJsonPath();
-    const existingRaw = await readRaw(path4);
+    const path3 = claudeJsonPath();
+    const existingRaw = await readRaw(path3);
     const markerIdentity = parseOauthIdentity(await readRaw(conveyorOauthMarkerPath()));
     await persistOauthIdentityMarker(
       extractOauthIdentity(parseClaudeJson(existingRaw)),
@@ -4764,16 +4679,16 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
     );
     const contents = planClaudeJsonSeed(existingRaw, trustCwd, markerIdentity);
     if (contents === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path4), contents);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path3), contents);
     if (verified) {
       process.stderr.write(
         `[conveyor-agent] claude onboarding seeded${trustCwd ? ` (trust: ${trustCwd})` : ""}
 `
       );
     } else {
-      const verify = await readRaw(path4);
+      const verify = await readRaw(path3);
       process.stderr.write(
-        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path4} 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 ${path3} after retries: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
 `
       );
     }
@@ -4786,12 +4701,12 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
 async function removeConveyorCredentials(env = process.env) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path4 = claudeCredentialsPath();
-    const existing = parseClaudeAiOauth(await readRaw(path4));
+    const path3 = claudeCredentialsPath();
+    const existing = parseClaudeAiOauth(await readRaw(path3));
     if (existing && typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
       return;
     }
-    await rm4(path4, { force: true });
+    await rm3(path3, { force: true });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[conveyor-agent] claude credentials removal failed: ${message}
@@ -4799,126 +4714,6 @@ async function removeConveyorCredentials(env = process.env) {
   }
 }
 
-// src/harness/pty/pty-support.ts
-import { stat as stat2 } from "fs/promises";
-var MAX_DIAGNOSTIC_OUTPUT = 4e3;
-var MAX_BETWEEN_TURN_BUFFER = 500;
-var SUBMIT_SETTLE_MS = 300;
-var SUBMIT_NUDGE_INTERVAL_MS = 2e3;
-var SUBMIT_NUDGE_MAX_PRESSES = 5;
-var SUBMIT_NUDGE_SLOW_INTERVAL_MS = 5e3;
-var SUBMIT_NUDGE_WINDOW_MS = 9e4;
-var PLAN_DIALOG_FIRST_PRESS_MS = 700;
-var PLAN_DIALOG_INTERVAL_MS = 1500;
-var PLAN_DIALOG_SLOW_INTERVAL_MS = 5e3;
-var PLAN_DIALOG_FAST_WINDOW_MS = 1e4;
-var PLAN_DIALOG_WINDOW_MS = 9e4;
-function envMs(name, fallback) {
-  const raw = Number(process.env[name]);
-  return Number.isFinite(raw) && raw > 0 ? raw : fallback;
-}
-function resolveSubmitSettleMs() {
-  return envMs("CONVEYOR_PTY_SUBMIT_SETTLE_MS", SUBMIT_SETTLE_MS);
-}
-function resolveSubmitNudgeTiming() {
-  return {
-    intervalMs: envMs("CONVEYOR_PTY_NUDGE_INTERVAL_MS", SUBMIT_NUDGE_INTERVAL_MS),
-    slowIntervalMs: envMs("CONVEYOR_PTY_NUDGE_SLOW_INTERVAL_MS", SUBMIT_NUDGE_SLOW_INTERVAL_MS),
-    maxPresses: SUBMIT_NUDGE_MAX_PRESSES,
-    windowMs: envMs("CONVEYOR_PTY_NUDGE_WINDOW_MS", SUBMIT_NUDGE_WINDOW_MS)
-  };
-}
-function resolvePlanDialogTiming() {
-  return {
-    firstPressMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_FIRST_PRESS_MS", PLAN_DIALOG_FIRST_PRESS_MS),
-    intervalMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_INTERVAL_MS", PLAN_DIALOG_INTERVAL_MS),
-    slowIntervalMs: envMs(
-      "CONVEYOR_PTY_PLAN_DIALOG_SLOW_INTERVAL_MS",
-      PLAN_DIALOG_SLOW_INTERVAL_MS
-    ),
-    fastWindowMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_FAST_WINDOW_MS", PLAN_DIALOG_FAST_WINDOW_MS),
-    windowMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_WINDOW_MS", PLAN_DIALOG_WINDOW_MS)
-  };
-}
-function turnOptionsFrom(options) {
-  return {
-    canUseTool: options.canUseTool,
-    promptDelivery: options.promptDelivery,
-    planDialogAutoAccept: options.planDialogAutoAccept,
-    abortController: options.abortController
-  };
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null;
-}
-function extractSpawn(mod) {
-  if (!isRecord3(mod)) return null;
-  if (typeof mod.spawn === "function") return mod.spawn;
-  const def = mod.default;
-  if (isRecord3(def) && typeof def.spawn === "function") return def.spawn;
-  return null;
-}
-async function loadPtySpawn() {
-  const mod = await import("node-pty");
-  const spawn2 = extractSpawn(mod);
-  if (!spawn2) throw new Error("node-pty: spawn export not found");
-  return spawn2;
-}
-function inheritedEnv(socketPath) {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (typeof value === "string") env[key] = value;
-  }
-  if (env.CLAUDE_CODE_OAUTH_TOKEN) {
-    delete env.ANTHROPIC_API_KEY;
-  }
-  if (socketPath) {
-    env.CONVEYOR_HOOK_SOCKET = socketPath;
-  }
-  env.MCP_TIMEOUT ??= "60000";
-  env.MCP_TOOL_TIMEOUT ??= "180000";
-  return env;
-}
-function buildPromptBytes(text) {
-  return `\x1B[200~${text}\x1B[201~`;
-}
-function renderPromptContentText(content) {
-  return content.map((block) => {
-    const b = block;
-    if (b?.type === "text" && typeof b.text === "string") return b.text;
-    if (b?.type === "image") {
-      return `[Image attachment \u2014 use list_task_files / get_attachment to view]`;
-    }
-    return JSON.stringify(block);
-  }).join("\n\n");
-}
-async function transcriptSize(path4) {
-  try {
-    return (await stat2(path4)).size;
-  } catch {
-    return 0;
-  }
-}
-function parseUserQuestions(input) {
-  if (!Array.isArray(input.questions)) return [];
-  const questions = [];
-  for (const entry of input.questions) {
-    if (!isRecord3(entry)) continue;
-    if (typeof entry.question !== "string") continue;
-    const options = Array.isArray(entry.options) ? entry.options.filter(isRecord3).filter((o) => typeof o.label === "string").map((o) => ({
-      label: o.label,
-      description: typeof o.description === "string" ? o.description : ""
-    })) : [];
-    questions.push({
-      question: entry.question,
-      header: typeof entry.header === "string" ? entry.header : "",
-      options,
-      ...typeof entry.multiSelect === "boolean" ? { multiSelect: entry.multiSelect } : {}
-    });
-  }
-  return questions;
-}
-
 // src/harness/pty/adapters/claude.ts
 var ClaudeTuiAdapter = class {
   id = "claude-code";
@@ -5029,6 +4824,18 @@ var PtySession = class {
   // Submit-nudge state (see armSubmitNudge).
   pendingSubmitNudge = false;
   submitNudgeTimer = null;
+  // Synthetic AskUserQuestion chat-card state. The CLI does NOT flush the
+  // assistant record holding a pending AskUserQuestion tool_use to the
+  // transcript until the questionnaire resolves (verified live on CLI 2.1.209:
+  // dialog parked on screen, transcript untouched) — so a transcript-derived
+  // question card could only ever render AFTER the human answered in the raw
+  // terminal. Instead the PreToolUse hook (which fires at ask time and carries
+  // the full questions input) emits a synthetic `tool_use` chat event under an
+  // `aq-…` id. When the real records eventually flush, the duplicate tool_use
+  // is dropped (FIFO match below) and its tool_result is re-pointed at the
+  // synthetic id so the card flips to answered.
+  pendingSyntheticQuestionIds = [];
+  questionResultRemap = /* @__PURE__ */ new Map();
   // Per-turn state: the prompt to feed and the per-turn options subset. Both
   // start from the constructor args (turn 1) and are replaced by beginTurn.
   turnPrompt;
@@ -5150,6 +4957,7 @@ var PtySession = class {
     this.passiveSignaled = false;
     this.disarmSubmitNudge();
     this.disarmPlanDialogAutoAccept();
+    this.closeSyntheticQuestionCards();
   }
   /**
    * (Re)register the abort→teardown listener on the current turn's controller,
@@ -5181,6 +4989,7 @@ var PtySession = class {
    */
   endTurn(clean) {
     this.lastTurnCleanResult = clean;
+    this.closeSyntheticQuestionCards();
     this.activeQueue?.close();
     this.activeQueue = null;
     if (this.abortHandler && this.turn.abortController) {
@@ -5205,7 +5014,7 @@ var PtySession = class {
         const { settingsPath, socketPath } = await this.startStructuredEventSources(sessionId);
         await this.spawn(settingsPath, socketPath);
       } else {
-        this.tempDir = await mkdtemp2(join4(tmpdir3(), "conveyor-pty-"));
+        this.tempDir = await mkdtemp2(join5(sessionTempBase(), "conveyor-pty-"));
         await this.spawn();
         this.pushEvent({
           type: "system",
@@ -5242,8 +5051,8 @@ var PtySession = class {
    * paths spawn() must wire into the child's argv/env.
    */
   async startStructuredEventSources(sessionId) {
-    this.tempDir = await mkdtemp2(join4(tmpdir3(), "conveyor-pty-"));
-    const socketPath = join4(this.tempDir, "hook.sock");
+    this.tempDir = await mkdtemp2(join5(sessionTempBase(), "conveyor-pty-"));
+    const socketPath = join5(this.tempDir, "hook.sock");
     this.socket = new HookSocketServer(
       socketPath,
       (progress) => this.handleProgress(progress),
@@ -5255,17 +5064,72 @@ var PtySession = class {
     const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
     await mkdir3(dirname(transcriptPath), { recursive: true });
     const startOffset = this.resume ? await transcriptSize(transcriptPath) : 0;
-    const sendChat = this.bridge?.sendChatEvent?.bind(this.bridge);
     this.tailer = new JsonlTailer(
       transcriptPath,
       (event) => this.handleTranscriptEvent(event),
-      sendChat ? (raw) => {
-        for (const chatEvent of mapChatRecords(raw)) sendChat(chatEvent);
-      } : void 0
+      typeof this.bridge?.sendChatEvent === "function" ? (raw) => this.relayChatRecord(raw) : void 0
     );
     this.tailer.start(startOffset);
     return { settingsPath, socketPath };
   }
+  /**
+   * Project a tailed transcript record to chat events, reconciling them with
+   * any synthetic question card already emitted at hook time: the flushed
+   * AskUserQuestion `tool_use` duplicate is dropped (its real id remembered),
+   * and the paired `tool_result` is re-pointed at the synthetic id so the
+   * live-rendered card is the one that flips to answered.
+   */
+  relayChatRecord(raw) {
+    for (const event of mapChatRecords(raw)) {
+      if (event.kind === "tool_use" && event.name === "AskUserQuestion") {
+        const syntheticId = this.pendingSyntheticQuestionIds.shift();
+        if (syntheticId) {
+          if (event.id) this.questionResultRemap.set(event.id, syntheticId);
+          continue;
+        }
+      } else if (event.kind === "tool_result" && event.toolUseId) {
+        const syntheticId = this.questionResultRemap.get(event.toolUseId);
+        if (syntheticId) {
+          this.questionResultRemap.delete(event.toolUseId);
+          this.sendChatEvent({ ...event, toolUseId: syntheticId });
+          continue;
+        }
+      }
+      this.sendChatEvent(event);
+    }
+  }
+  sendChatEvent(event) {
+    this.bridge?.sendChatEvent?.(event);
+  }
+  /** Render the question card in the web chat NOW — at hook time — instead of
+   * whenever the CLI flushes the transcript records (which is only after the
+   * questionnaire resolves; see the field comment). */
+  emitSyntheticQuestionCard(questions) {
+    if (questions.length === 0 || typeof this.bridge?.sendChatEvent !== "function") return;
+    const id = `aq-${randomUUID2()}`;
+    this.pendingSyntheticQuestionIds.push(id);
+    this.sendChatEvent({
+      kind: "tool_use",
+      name: "AskUserQuestion",
+      input: compactQuestionsJson(questions),
+      id
+    });
+  }
+  /**
+   * Close any still-open synthetic question cards. The questionnaire can only
+   * outlive its card via a path that never flushes the paired records — Esc /
+   * interrupt, a superseding turn, or process teardown — so an answering
+   * tool_result will never arrive for these ids; emit one so the web card
+   * stops soliciting input for a dialog that no longer exists.
+   */
+  closeSyntheticQuestionCards() {
+    const orphaned = [...this.pendingSyntheticQuestionIds, ...this.questionResultRemap.values()];
+    this.pendingSyntheticQuestionIds = [];
+    this.questionResultRemap.clear();
+    for (const toolUseId of orphaned) {
+      this.sendChatEvent({ kind: "tool_result", toolUseId, output: "", isError: false });
+    }
+  }
   writeStdin(text) {
     this.pty?.write(text);
   }
@@ -5299,6 +5163,7 @@ var PtySession = class {
     this._toreDown = true;
     this.disarmPlanDialogAutoAccept();
     this.disarmSubmitNudge();
+    this.closeSyntheticQuestionCards();
     this.unsubInput?.();
     this.unsubInput = null;
     this.unsubResize?.();
@@ -5331,7 +5196,7 @@ var PtySession = class {
     this.activeQueue?.close();
     this.activeQueue = null;
     if (this.tempDir) {
-      await rm5(this.tempDir, { recursive: true, force: true });
+      await rm4(this.tempDir, { recursive: true, force: true });
       this.tempDir = "";
     }
   }
@@ -5360,8 +5225,8 @@ var PtySession = class {
       // server doesn't load).
       ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {}
     });
-    const spawn2 = await loadPtySpawn();
-    const pty = spawn2(spec.file, spec.args, {
+    const spawn = await resolvePtySpawn();
+    const pty = spawn(spec.file, spec.args, {
       name: "xterm-color",
       cols: this.cols,
       rows: this.rows,
@@ -5469,10 +5334,9 @@ var PtySession = class {
     if (request.tool_name === "AskUserQuestion") {
       this.disarmSubmitNudge();
       this.disarmPlanDialogAutoAccept();
-      this.pushEvent({
-        type: "user_question",
-        questions: parseUserQuestions(request.tool_input)
-      });
+      const questions = parseUserQuestions(request.tool_input);
+      this.pushEvent({ type: "user_question", questions });
+      this.emitSyntheticQuestionCard(questions);
       return { decision: "allow" };
     }
     const canUseTool = this.turn.canUseTool;
@@ -5608,7 +5472,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 join5 } from "path";
+import { join as join6 } from "path";
 var MOUNT_DISCONNECT_CODES = /* @__PURE__ */ new Set(["ENOTCONN", "EIO", "ESTALE", "ENXIO"]);
 var MOUNT_DISCONNECT_MESSAGES = [
   "socket is not connected",
@@ -5624,12 +5488,12 @@ function isMountDisconnectError(err) {
   return MOUNT_DISCONNECT_MESSAGES.some((needle) => lower.includes(needle));
 }
 function podLocalConfigHome() {
-  return join5(homedir3(), ".claude-local");
+  return join6(homedir3(), ".claude-local");
 }
 async function ensureUsableClaudeConfigHome(cwd, log) {
   const configHome = claudeConfigHome();
   try {
-    await mkdir4(join5(configHome, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join6(configHome, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome, fellBack: false };
   } catch (err) {
     if (!isMountDisconnectError(err)) throw err;
@@ -5643,7 +5507,7 @@ async function ensureUsableClaudeConfigHome(cwd, log) {
       }
     );
     process.env.CLAUDE_CONFIG_DIR = fallback;
-    await mkdir4(join5(fallback, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join6(fallback, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome: fallback, fellBack: true };
   }
 }
@@ -6089,8 +5953,38 @@ function formatIncidents(incidents) {
   return parts;
 }
 
+// src/workbench/fs.ts
+import { readFile as localReadFile, readdir as localReaddir, stat as localStat } from "fs/promises";
+async function readWorkspaceFile(path3) {
+  if (workbenchEnabled()) {
+    return (await getWorkbenchClient().readFile(path3)).toString("utf8");
+  }
+  return localReadFile(path3, "utf-8");
+}
+function readWorkspaceDir(path3) {
+  if (workbenchEnabled()) return getWorkbenchClient().readdir(path3);
+  return localReaddir(path3);
+}
+async function statWorkspacePath(path3) {
+  if (workbenchEnabled()) return getWorkbenchClient().stat(path3);
+  try {
+    const s = await localStat(path3);
+    return {
+      exists: true,
+      isFile: s.isFile(),
+      isDirectory: s.isDirectory(),
+      size: s.size,
+      mtimeMs: s.mtimeMs
+    };
+  } catch {
+    return { exists: false, isFile: false, isDirectory: false, size: 0, mtimeMs: 0 };
+  }
+}
+async function workspacePathExists(path3) {
+  return (await statWorkspacePath(path3)).exists;
+}
+
 // src/execution/tag-context-resolver.ts
-import { readFile as readFile2, readdir, stat as stat3 } from "fs/promises";
 var TYPE_PRIORITY = { rule: 0, file: 1, folder: 2, doc: 3 };
 var SUMMARY_SCAN_CHARS = 4e3;
 var SUMMARY_MAX_CHARS = 160;
@@ -6162,18 +6056,14 @@ function truncateSummary(text) {
 async function readFileSummary(filePath) {
   try {
     if (isBinaryPath(filePath)) return null;
-    let mtimeMs;
-    try {
-      const st = await stat3(filePath);
-      mtimeMs = st.mtimeMs;
-    } catch {
-      return null;
-    }
+    const st = await statWorkspacePath(filePath);
+    if (!st.exists) return null;
+    const mtimeMs = st.mtimeMs;
     const cached = fileSummaryCache.get(filePath);
     if (cached && cached.mtimeMs === mtimeMs) {
       return cached.summary;
     }
-    const raw = await readFile2(filePath, "utf-8");
+    const raw = await readWorkspaceFile(filePath);
     fileReadCount++;
     const summary = deriveSummary(raw.slice(0, SUMMARY_SCAN_CHARS));
     fileSummaryCache.set(filePath, { mtimeMs, summary });
@@ -6184,18 +6074,14 @@ async function readFileSummary(filePath) {
 }
 async function readFolderListing(folderPath) {
   try {
-    let mtimeMs;
-    try {
-      const st = await stat3(folderPath);
-      mtimeMs = st.mtimeMs;
-    } catch {
-      return null;
-    }
+    const st = await statWorkspacePath(folderPath);
+    if (!st.exists) return null;
+    const mtimeMs = st.mtimeMs;
     const cached = folderListingCache.get(folderPath);
     if (cached && cached.mtimeMs === mtimeMs) {
       return cached.listing;
     }
-    const entries = await readdir(folderPath);
+    const entries = await readWorkspaceDir(folderPath);
     folderReadCount++;
     const listing = `Files: ${entries.join(", ")}`;
     folderListingCache.set(folderPath, { mtimeMs, listing });
@@ -7582,7 +7468,16 @@ function buildForceUpdateTaskStatusTool(connection) {
     "force_update_task_status",
     "EMERGENCY ONLY: force-override a task's Kanban status. Use when an automatic transition failed and the task is wedged. Normal flow transitions status automatically.",
     {
-      status: z9.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
+      status: z9.enum([
+        "Planning",
+        "Open",
+        "InProgress",
+        "ReviewPR",
+        "ReviewDev",
+        "ReviewLive",
+        "Complete",
+        "Cancelled"
+      ]).describe("The new status for the task"),
       task_id: z9.string().optional().describe("Child task ID to update. Omit to update the current task.")
     },
     async ({ status, task_id }) => {
@@ -7846,8 +7741,8 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { readFile as readFile3, stat as stat4 } from "fs/promises";
-import { basename, extname, isAbsolute, join as join6 } from "path";
+import { readFile as readFile2, stat } from "fs/promises";
+import { basename, extname, isAbsolute, join as join7 } from "path";
 import { z as z10 } from "zod";
 var IMAGE_MIME_BY_EXT = {
   ".png": "image/png",
@@ -7864,16 +7759,16 @@ 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: path4, title }) => {
+    async ({ path: path3, title }) => {
       try {
-        const filePath = isAbsolute(path4) ? path4 : join6(config.workspaceDir, path4);
+        const filePath = isAbsolute(path3) ? path3 : join7(config.workspaceDir, path3);
         const mimeType = IMAGE_MIME_BY_EXT[extname(filePath).toLowerCase()];
         if (!mimeType) {
           return textResult(
             `Unsupported file type "${extname(filePath) || "(none)"}". Supported: ${Object.keys(IMAGE_MIME_BY_EXT).join(", ")}`
           );
         }
-        const info = await stat4(filePath).catch(() => null);
+        const info = await stat(filePath).catch(() => null);
         if (!info?.isFile()) {
           return textResult(`File not found: ${filePath}`);
         }
@@ -7889,7 +7784,7 @@ function buildUploadAttachmentTool(connection, config) {
           mimeType,
           fileSize: info.size
         });
-        const body = await readFile3(filePath);
+        const body = await readFile2(filePath);
         const res = await fetch(uploadUrl, {
           method: "PUT",
           headers: { "Content-Type": mimeType },
@@ -8399,42 +8294,52 @@ function buildPmTools(connection, options) {
 // src/tools/discovery-tools.ts
 import { z as z13 } from "zod";
 var SP_DESCRIPTION2 = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique). The key is 'storyPointValue' \u2014 not 'storyPoints'.";
-var VALID_PROPERTY_KEYS = "title, storyPointValue, tagNames, githubPRUrl, githubBranch";
+var VALID_PROPERTY_KEYS = "title, storyPointValue, tagNames, githubPRUrl, githubBranch, risk";
+function describeUpdatedFields(p) {
+  const fields = [];
+  if (p.title !== void 0) fields.push(`title to "${p.title}"`);
+  if (p.storyPointValue !== void 0) fields.push(`story points to ${p.storyPointValue}`);
+  if (p.tagNames !== void 0) fields.push(`tags (${p.tagNames.length} tag(s))`);
+  if (p.githubPRUrl !== void 0) fields.push(`PR link to "${p.githubPRUrl}"`);
+  if (p.githubBranch !== void 0) fields.push(`branch to "${p.githubBranch}"`);
+  if (p.risk !== void 0) fields.push(`risk to ${p.risk ?? "cleared"}`);
+  return fields;
+}
 function buildDiscoveryTools(connection) {
   return [
     defineTool(
       "update_task_properties",
-      "Set one or more task properties in a single call. Valid keys: title, storyPointValue, tagNames, githubPRUrl, githubBranch. All are optional \u2014 include only the ones you want to update (at least one). Unknown keys are rejected.",
+      "Set one or more task properties in a single call. Valid keys: title, storyPointValue, tagNames, githubPRUrl, githubBranch, risk. All are optional \u2014 include only the ones you want to update (at least one). Unknown keys are rejected.",
       {
         title: z13.string().optional().describe("The new task title"),
         storyPointValue: z13.number().optional().describe(SP_DESCRIPTION2),
         tagNames: z13.array(z13.string()).optional().describe("Array of tag names to assign"),
         githubPRUrl: z13.string().url().optional().describe("GitHub pull request URL to link to this task"),
-        githubBranch: z13.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')")
+        githubBranch: z13.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')"),
+        risk: z13.enum(["critical", "high", "medium", "low"]).nullable().optional().describe(
+          "Risk level \u2014 how much important surface the task touches (critical/high/medium/low). Pass null to clear."
+        )
       },
-      async ({ title, storyPointValue, tagNames, githubPRUrl, githubBranch }) => {
+      async ({ title, storyPointValue, tagNames, githubPRUrl, githubBranch, risk }) => {
         try {
-          const nothingToUpdate = title === void 0 && storyPointValue === void 0 && tagNames === void 0 && githubPRUrl === void 0 && githubBranch === void 0;
-          if (nothingToUpdate) {
+          const params = {
+            title,
+            storyPointValue,
+            tagNames,
+            githubPRUrl,
+            githubBranch,
+            risk
+          };
+          const updatedFields = describeUpdatedFields(params);
+          if (updatedFields.length === 0) {
             return textResult(
               `No task properties were updated: none of the recognized keys were provided. Valid keys: ${VALID_PROPERTY_KEYS}. (Story points are set via 'storyPointValue', not 'storyPoints'.)`
             );
           }
           await connection.call("updateTaskProperties", {
             sessionId: connection.sessionId,
-            title,
-            storyPointValue,
-            tagNames,
-            githubPRUrl,
-            githubBranch
+            ...params
           });
-          const updatedFields = [];
-          if (title !== void 0) updatedFields.push(`title to "${title}"`);
-          if (storyPointValue !== void 0)
-            updatedFields.push(`story points to ${storyPointValue}`);
-          if (tagNames !== void 0) updatedFields.push(`tags (${tagNames.length} tag(s))`);
-          if (githubPRUrl !== void 0) updatedFields.push(`PR link to "${githubPRUrl}"`);
-          if (githubBranch !== void 0) updatedFields.push(`branch to "${githubBranch}"`);
           return textResult(`Task properties updated: ${updatedFields.join(", ")}`);
         } catch (error) {
           return textResult(
@@ -8618,7 +8523,7 @@ function createConveyorMcpServer(harness, connection, config, context, agentMode
 
 // src/harness/pty/adapters/types.ts
 import { accessSync, constants, statSync } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var TuiUnavailableError = class extends Error {
   constructor(tui, message) {
     super(message);
@@ -8627,10 +8532,10 @@ var TuiUnavailableError = class extends Error {
   }
   tui;
 };
-function isExecutable(path4) {
+function isExecutable(path3) {
   try {
-    if (!statSync(path4).isFile()) return false;
-    accessSync(path4, constants.X_OK);
+    if (!statSync(path3).isFile()) return false;
+    accessSync(path3, constants.X_OK);
     return true;
   } catch {
     return false;
@@ -8642,7 +8547,7 @@ function findOnPath(binary, env = process.env) {
   }
   for (const dir of (env.PATH ?? "").split(":")) {
     if (!dir) continue;
-    const candidate = join7(dir, binary);
+    const candidate = join8(dir, binary);
     if (isExecutable(candidate)) return candidate;
   }
   return null;
@@ -8974,14 +8879,14 @@ function flushPendingToolCalls(host, turnToolCalls) {
   }
   const outputsByTool = /* @__PURE__ */ new Map();
   for (const entry of host.pendingToolOutputs) {
-    const list2 = outputsByTool.get(entry.tool) ?? [];
-    list2.push(entry.output);
-    outputsByTool.set(entry.tool, list2);
+    const list = outputsByTool.get(entry.tool) ?? [];
+    list.push(entry.output);
+    outputsByTool.set(entry.tool, list);
   }
   for (const call of turnToolCalls) {
-    const list2 = outputsByTool.get(call.tool);
-    if (list2 && list2.length > 0) {
-      call.output = list2.shift();
+    const list = outputsByTool.get(call.tool);
+    if (list && list.length > 0) {
+      call.output = list.shift();
     }
   }
   host.connection.sendEvent({ type: "turn_end", toolCalls: [...turnToolCalls] });
@@ -9506,10 +9411,10 @@ function resolveSessionStart(lineageKey, cwd) {
   }
   return { sessionId: sessionUuid };
 }
-function repairTornSessionFile(path4) {
+function repairTornSessionFile(path3) {
   try {
-    if (!existsSync2(path4)) return false;
-    const content = readFileSync(path4, "utf8");
+    if (!existsSync2(path3)) return false;
+    const content = readFileSync(path3, "utf8");
     if (content.length === 0) return false;
     let keepEnd = content.length;
     if (!content.endsWith("\n")) {
@@ -9528,9 +9433,9 @@ function repairTornSessionFile(path4) {
       keepEnd = prevNewline + 1;
     }
     if (keepEnd === content.length) return false;
-    truncateSync(path4, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
+    truncateSync(path3, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
     logger2.warn("Repaired torn transcript before resume", {
-      path: path4,
+      path: path3,
       trimmedBytes: content.length - keepEnd
     });
     return true;
@@ -10328,7 +10233,7 @@ var QueryBridge = class {
 
 // src/runner/session-runner-helpers.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname2, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
@@ -10357,7 +10262,7 @@ function readAgentVersion() {
     const here = dirname2(fileURLToPath2(import.meta.url));
     for (const rel of ["../package.json", "../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync2(join8(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync2(join9(here, rel), "utf-8"));
         if (pkg.version) return pkg.version;
       } catch {
       }
@@ -10563,10 +10468,10 @@ var UsageProbeRun = class {
   }
 };
 async function runUsageProbe(deps = {}) {
-  let spawn2 = deps.spawn;
-  if (!spawn2) {
+  let spawn = deps.spawn;
+  if (!spawn) {
     try {
-      spawn2 = await loadPtySpawn();
+      spawn = await loadPtySpawn();
     } catch {
       return "";
     }
@@ -10582,7 +10487,7 @@ async function runUsageProbe(deps = {}) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn2(binary, [], {
+      child = spawn(binary, [], {
         name: "xterm-256color",
         cols: 120,
         rows: 45,
@@ -10656,14 +10561,14 @@ async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscript
 }
 
 // src/setup/git-ready.ts
-import { access, stat as stat5 } from "fs/promises";
+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(path4) {
+async function fileExists(path3) {
   try {
-    await access(path4);
-    const s = await stat5(path4);
+    await access(path3);
+    const s = await stat2(path3);
     return s.isFile();
   } catch {
     return false;
@@ -10726,8 +10631,8 @@ async function pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, onLog,
 }
 
 // src/runner/port-discovery.ts
-import { readFile as readFile4 } from "fs/promises";
-import { execFile as execFile3 } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
 var PROC_TCP_LISTEN_STATE = "0A";
 function isLoopbackHexAddress(hex) {
   const addr = hex.toUpperCase();
@@ -10778,9 +10683,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 path4 of procPaths) {
+  for (const path3 of procPaths) {
     try {
-      const content = await readFile4(path4, "utf8");
+      const content = await readFile3(path3, "utf8");
       readable = true;
       sockets.push(...parseProcNetTcpListeners(content));
     } catch {
@@ -10790,7 +10695,7 @@ async function readProcListeningPorts(procPaths = DEFAULT_PROC_PATHS) {
 }
 async function readNetstatListeningPorts() {
   const output = await new Promise((resolve) => {
-    execFile3("netstat", ["-an", "-p", "tcp"], { timeout: 5e3 }, (err, stdout) => {
+    execFile2("netstat", ["-an", "-p", "tcp"], { timeout: 5e3 }, (err, stdout) => {
       resolve(err ? null : stdout);
     });
   });
@@ -10963,9 +10868,9 @@ var PortDiscovery = class {
 };
 
 // src/runner/parent-pull-handler.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile4);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile3);
 async function handlePullBranch(workDir, branch) {
   if (!branch) return;
   const current = await getCurrentBranch(workDir);
@@ -10984,14 +10889,14 @@ async function handlePullBranch(workDir, branch) {
     return;
   }
   try {
-    await execFileAsync3("git", ["fetch", "origin", branch], { cwd: workDir, timeout: 6e4 });
+    await execFileAsync2("git", ["fetch", "origin", branch], { cwd: workDir, timeout: 6e4 });
   } catch {
     process.stderr.write(`[conveyor-agent] pull_branch: fetch failed for ${branch}
 `);
     return;
   }
   try {
-    await execFileAsync3("git", ["pull", "--ff-only", "origin", branch], {
+    await execFileAsync2("git", ["pull", "--ff-only", "origin", branch], {
       cwd: workDir,
       timeout: 6e4
     });
@@ -11007,7 +10912,7 @@ async function handlePullBranch(workDir, branch) {
 
 // src/runner/heavy-gate.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path3 from "path";
+import path2 from "path";
 var GATE_KEYS = ["heavy", "test", "typecheck", "build"];
 function runDir() {
   return process.env.CONVEYOR_RUN_DIR ?? "/tmp/conveyor-run";
@@ -11023,7 +10928,7 @@ function pidAlive(pid) {
 function isHeavyGateActive() {
   for (const key of GATE_KEYS) {
     try {
-      const raw = readFileSync3(path3.join(runDir(), `${key}.pid`), "utf8").trim();
+      const raw = readFileSync3(path2.join(runDir(), `${key}.pid`), "utf8").trim();
       const pid = Number.parseInt(raw, 10);
       if (Number.isInteger(pid) && pid > 0 && pidAlive(pid)) return true;
     } catch {
@@ -11924,13 +11829,12 @@ var SessionRunner = class _SessionRunner {
 };
 
 // src/setup/config.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } 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 readFile5(join9(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readWorkspaceFile(join10(workspaceDir, DEVCONTAINER_PATH));
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -11971,125 +11875,11 @@ function loadConveyorConfig() {
   return null;
 }
 
-// src/setup/commands.ts
-import { spawn, execSync } from "child_process";
-var PROCESS_TERMINATION_GRACE_MS = 5e3;
-function abortError2() {
-  const error = new Error("Operation aborted");
-  error.name = "AbortError";
-  return error;
-}
-function signalProcessGroup(child, signal) {
-  try {
-    if (child.pid) process.kill(-child.pid, signal);
-    else child.kill(signal);
-  } catch {
-    try {
-      child.kill(signal);
-    } catch {
-    }
-  }
-}
-function terminateProcessGroup(child, graceMs = PROCESS_TERMINATION_GRACE_MS) {
-  if (child.exitCode !== null) return Promise.resolve();
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      child.removeListener("exit", finish);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signalProcessGroup(child, "SIGKILL");
-      finish();
-    }, graceMs);
-    timer.unref();
-    child.once("exit", finish);
-    signalProcessGroup(child, "SIGTERM");
-  });
-}
-function runSetupCommand(cmd, cwd, onOutput, signal) {
-  if (signal?.aborted) return Promise.reject(abortError2());
-  return new Promise((resolve, reject) => {
-    const child = spawn("sh", ["-c", cmd], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-      env: { ...process.env }
-    });
-    let settled = false;
-    let aborting = false;
-    const cleanup = () => signal?.removeEventListener("abort", onAbort);
-    const settle = (error) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      if (error) reject(error);
-      else resolve();
-    };
-    const onAbort = () => {
-      if (settled || aborting) return;
-      aborting = true;
-      void terminateProcessGroup(child).then(() => settle(abortError2()));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-    if (signal?.aborted) onAbort();
-    child.stdout.on("data", (chunk) => {
-      if (aborting || signal?.aborted) return;
-      onOutput("stdout", chunk.toString());
-    });
-    child.stderr.on("data", (chunk) => {
-      if (aborting || signal?.aborted) return;
-      onOutput("stderr", chunk.toString());
-    });
-    child.on("close", (code) => {
-      if (aborting) return;
-      settle(code === 0 ? void 0 : new Error(`Setup command exited with code ${code}`));
-    });
-    child.on("error", (err) => {
-      if (!aborting) settle(err);
-    });
-  });
-}
-var AUTH_TOKEN_TIMEOUT_MS = 3e4;
-function runAuthTokenCommand(cmd, userEmail, cwd) {
-  try {
-    const output = execSync(`${cmd} ${JSON.stringify(userEmail)}`, {
-      cwd,
-      timeout: AUTH_TOKEN_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "ignore"],
-      env: { ...process.env }
-    });
-    const token = output.toString().trim();
-    return token || null;
-  } catch {
-    return null;
-  }
-}
-function runStartCommand(cmd, cwd, onOutput) {
-  const child = spawn("sh", ["-c", cmd], {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: { ...process.env }
-  });
-  child.stdout.on("data", (chunk) => {
-    onOutput("stdout", chunk.toString());
-  });
-  child.stderr.on("data", (chunk) => {
-    onOutput("stderr", chunk.toString());
-  });
-  child.unref();
-  return child;
-}
-
 // src/setup/codespace.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 function unshallowRepo(workspaceDir) {
   try {
-    execSync2("git fetch --unshallow", {
+    execSync("git fetch --unshallow", {
       cwd: workspaceDir,
       timeout: 6e4,
       stdio: "ignore"
@@ -12110,12 +11900,10 @@ export {
   cleanTerminalOutput,
   buildSynthesizedCredentials,
   claudeJsonPath,
-  loadPtySpawn,
-  inheritedEnv,
-  buildPromptBytes,
   ClaudeTuiAdapter,
   createServiceLogger,
   PtyHarness,
+  workspacePathExists,
   textResult,
   GIT_TIMEOUT_MS,
   hasUncommittedChanges,
@@ -12144,10 +11932,6 @@ export {
   loadForwardPorts,
   buildSessionPreviewPorts,
   loadConveyorConfig,
-  terminateProcessGroup,
-  runSetupCommand,
-  runAuthTokenCommand,
-  runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-AJZIO5QI.js.map
+//# sourceMappingURL=chunk-UVR5XFE4.js.map