@rallycry/conveyor-agent 11.0.2 → 11.0.4

package/dist/{chunk-QETNCXIR.js → chunk-HYPX6FEX.js}

@@ -2,6 +2,32 @@ import {
   mapChatHistory,
   readAgentVersion
 } from "./chunk-XORJ6SII.js";
+import {
+  MAX_BETWEEN_TURN_BUFFER,
+  MAX_DIAGNOSTIC_OUTPUT,
+  buildExitErrors,
+  buildPromptBytes,
+  buildSpawnArgs,
+  cleanTerminalOutput,
+  inheritedEnv,
+  killPtyWithEscalation,
+  needsRawReadyGate,
+  parseUserQuestions,
+  renderPromptContentText,
+  resolveClaudeBinary,
+  resolvePlanDialogTiming,
+  resolvePtySpawn,
+  resolveRawTuiProbeTiming,
+  resolveSubmitNudgeTiming,
+  resolveSubmitRedeliveryMaxAttempts,
+  resolveSubmitSettleMs,
+  sawTerminalSetup,
+  sentinelEchoed,
+  sessionTempBase,
+  spawnOptionsFingerprint,
+  transcriptSize,
+  turnOptionsFrom
+} from "./chunk-3F4ZZKCA.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -30,11 +56,21 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-N4WSUTGV.js";
+} from "./chunk-SLUBOIYE.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
 } from "./chunk-GL2DIQEQ.js";
+import {
+  describeTokenFile,
+  ghHostsExternallyOwned,
+  githubTokenFilePath,
+  sleep
+} from "./chunk-W4LZ7R6Z.js";
+import {
+  isHeavyGateActive,
+  listGateExitSentinels
+} from "./chunk-7P6QZHXZ.js";
 import {
   LoopLagMonitor,
   loopStatusForRunnerStatus
@@ -45,38 +81,6 @@ import {
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
-import {
-  MAX_BETWEEN_TURN_BUFFER,
-  MAX_DIAGNOSTIC_OUTPUT,
-  buildExitErrors,
-  buildPromptBytes,
-  buildSpawnArgs,
-  cleanTerminalOutput,
-  inheritedEnv,
-  killPtyWithEscalation,
-  needsRawReadyGate,
-  parseUserQuestions,
-  renderPromptContentText,
-  resolveClaudeBinary,
-  resolvePlanDialogTiming,
-  resolvePtySpawn,
-  resolveRawTuiProbeTiming,
-  resolveSubmitNudgeTiming,
-  resolveSubmitRedeliveryMaxAttempts,
-  resolveSubmitSettleMs,
-  sawTerminalSetup,
-  sentinelEchoed,
-  sessionTempBase,
-  spawnOptionsFingerprint,
-  transcriptSize,
-  turnOptionsFrom
-} from "./chunk-3F4ZZKCA.js";
-import {
-  describeTokenFile,
-  ghHostsExternallyOwned,
-  githubTokenFilePath,
-  sleep
-} from "./chunk-W4LZ7R6Z.js";
 
 // ../shared/dist/chunk-OKJPFFQI.js
 var CARD_DESCRIPTION_MAX = 255;
@@ -3134,8 +3138,8 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path2, onEvent, onRawRecord, mapRecord = mapTranscriptRecord) {
-    this.path = path2;
+  constructor(path, onEvent, onRawRecord, mapRecord = mapTranscriptRecord) {
+    this.path = path;
     this.onEvent = onEvent;
     this.onRawRecord = onRawRecord;
     this.mapRecord = mapRecord;
@@ -3991,11 +3995,13 @@ function conveyorCredentialsMarkerPath() {
 function tokenFingerprint(accessToken) {
   return createHash("sha256").update(accessToken).digest("hex");
 }
-function buildCredentialsMarker(accessToken, now, previousHash) {
+function buildCredentialsMarker(accessToken, now, previousHash, refreshToken, codingAgentKeyId) {
   const accessTokenSha256 = tokenFingerprint(accessToken);
   return JSON.stringify({
     accessTokenSha256,
     ...previousHash && previousHash !== accessTokenSha256 ? { previousAccessTokenSha256: previousHash } : {},
+    ...refreshToken ? { refreshTokenSha256: tokenFingerprint(refreshToken) } : {},
+    ...codingAgentKeyId ? { codingAgentKeyId } : {},
     writtenAt: now
   });
 }
@@ -4012,16 +4018,59 @@ function parseCredentialsMarker(raw) {
     return [];
   }
 }
+function parseCredentialsRefreshMarker(raw) {
+  if (!raw || raw.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const hash = parsed.refreshTokenSha256;
+    return typeof hash === "string" && hash.length > 0 ? hash : null;
+  } catch {
+    return null;
+  }
+}
+function parseCredentialsMarkerKeyId(raw) {
+  if (!raw || raw.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const keyId = parsed.codingAgentKeyId;
+    return typeof keyId === "string" && keyId.length > 0 ? keyId : null;
+  } catch {
+    return null;
+  }
+}
+function credentialMarkerMatches(raw, accessToken, refreshToken, expectedKeyId) {
+  if (expectedKeyId && parseCredentialsMarkerKeyId(raw) !== expectedKeyId) return false;
+  if (accessToken && parseCredentialsMarker(raw).includes(tokenFingerprint(accessToken)))
+    return true;
+  if (!refreshToken) return false;
+  return parseCredentialsRefreshMarker(raw) === tokenFingerprint(refreshToken);
+}
+function parseCredentialsIdentity(credentialsRaw, markerRaw, expectedKeyId) {
+  if (!credentialsRaw) return null;
+  try {
+    const parsed = JSON.parse(credentialsRaw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const oauth = parsed.claudeAiOauth;
+    if (typeof oauth !== "object" || oauth === null) return null;
+    const record = oauth;
+    const accessToken = typeof record.accessToken === "string" ? record.accessToken : null;
+    const refreshToken = typeof record.refreshToken === "string" ? record.refreshToken : null;
+    return {
+      accessToken,
+      hasRefreshToken: Boolean(refreshToken),
+      isConveyorOwned: credentialMarkerMatches(markerRaw, accessToken, refreshToken, expectedKeyId)
+    };
+  } catch {
+    return null;
+  }
+}
 
-// src/harness/pty/credentials.ts
+// src/harness/pty/credentials-plan.ts
 var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
 var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
-function claudeCredentialsPath() {
-  return join5(claudeConfigHome(), ".credentials.json");
-}
-function isConveyorCloudEnv(env = process.env) {
-  return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
-}
+var LEGACY_SCOPES = ["user:inference", "user:profile"];
 function parseClaudeOauthEnv(blob) {
   if (!blob) return null;
   try {
@@ -4029,7 +4078,7 @@ function parseClaudeOauthEnv(blob) {
     if (typeof parsed !== "object" || parsed === null) return null;
     const record = parsed;
     if (typeof record.access !== "string" || record.access === "") return null;
-    const scopes = Array.isArray(record.scopes) ? record.scopes.filter((s) => typeof s === "string" && s.length > 0) : [];
+    const scopes = Array.isArray(record.scopes) ? record.scopes.filter((scope) => typeof scope === "string" && scope !== "") : [];
     return {
       access: record.access,
       refresh: typeof record.refresh === "string" && record.refresh ? record.refresh : void 0,
@@ -4059,19 +4108,13 @@ function parseClaudeAiOauth(raw) {
     return null;
   }
 }
-var LEGACY_SCOPES = ["user:inference", "user:profile"];
 function buildCredentialsFile(material, now) {
   const refresh = material.refresh;
   return JSON.stringify({
     claudeAiOauth: {
       accessToken: material.access,
       ...refresh ? { refreshToken: refresh } : {},
-      // With a refresh token the CLI can recover from a real expiry, so report
-      // the true one. Without, claim a far-future expiry (see SYNTH_TOKEN_TTL_MS)
-      // because a refresh attempt would be unrecoverable.
       expiresAt: refresh && material.expires ? material.expires : now + SYNTH_TOKEN_TTL_MS,
-      // The refresh token has its own expiry; the CLI records it, so mirror it
-      // when the grant told us rather than leaving the field off.
       ...material.refreshExpires ? { refreshTokenExpiresAt: material.refreshExpires } : {},
       scopes: material.scopes?.length ? material.scopes : LEGACY_SCOPES,
       ...material.rateLimitTier ? { rateLimitTier: material.rateLimitTier } : {},
@@ -4083,31 +4126,74 @@ function buildSynthesizedCredentials(token, now) {
   return buildCredentialsFile({ access: token }, now);
 }
 function isConveyorOwnedCredentials(existing, markerHashes) {
-  const hasRefresh = typeof existing.refreshToken === "string" && existing.refreshToken.length > 0;
+  const hasRefresh = typeof existing.refreshToken === "string" && existing.refreshToken !== "";
   if (!hasRefresh) return true;
-  if (markerHashes.length === 0) return false;
   if (typeof existing.accessToken !== "string") return false;
   return markerHashes.includes(tokenFingerprint(existing.accessToken));
 }
+function hasStableRefreshOwnership(existing, markerRaw) {
+  return typeof existing.refreshToken === "string" && parseCredentialsRefreshMarker(markerRaw) === tokenFingerprint(existing.refreshToken);
+}
+function isCurrentCredential(existing, material, now) {
+  if (material.refresh) return existing.accessToken === material.access;
+  return existing.accessToken === material.access && typeof existing.expiresAt === "number" && existing.expiresAt > now + REFRESH_SKEW_MS;
+}
+function needsMarkerUpgrade(input, material) {
+  if (!input.codingAgentKeyId) return false;
+  if (parseCredentialsMarkerKeyId(input.markerRaw ?? null) !== input.codingAgentKeyId) return true;
+  return Boolean(
+    material.refresh && parseCredentialsRefreshMarker(input.markerRaw ?? null) !== tokenFingerprint(material.refresh)
+  );
+}
+function ownsExistingCredential(existing, markerRaw, markerHashes) {
+  if (isConveyorOwnedCredentials(existing, markerHashes)) return true;
+  const accessToken = typeof existing.accessToken === "string" ? existing.accessToken : null;
+  const refreshToken = typeof existing.refreshToken === "string" ? existing.refreshToken : null;
+  return credentialMarkerMatches(markerRaw, accessToken, refreshToken);
+}
+function cliRefreshedSameKey(input, material, existing, markerRaw) {
+  if (!material.refresh || !input.codingAgentKeyId) return false;
+  if (parseCredentialsMarkerKeyId(markerRaw) !== input.codingAgentKeyId) return false;
+  return hasStableRefreshOwnership(existing, markerRaw) && existing.accessToken !== material.access;
+}
 function planCredentialsWrite(input) {
   if (!input.isCloud) return { action: "skip", reason: "not-cloud" };
   const material = parseClaudeOauthEnv(input.oauthBlob) ?? (input.token ? { access: input.token } : null);
   if (!material) return { action: "skip", reason: "no-token" };
-  const markerHashes = parseCredentialsMarker(input.markerRaw ?? null);
+  const markerRaw = input.markerRaw ?? null;
+  const markerHashes = parseCredentialsMarker(markerRaw);
   const contents = buildCredentialsFile(material, input.now);
-  const marker = buildCredentialsMarker(material.access, input.now, markerHashes[0] ?? null);
+  const marker = buildCredentialsMarker(
+    material.access,
+    input.now,
+    markerHashes[0] ?? null,
+    material.refresh,
+    input.codingAgentKeyId
+  );
   const existing = parseClaudeAiOauth(input.existingRaw);
   if (!existing) return { action: "write", contents, marker };
-  if (!isConveyorOwnedCredentials(existing, markerHashes)) {
+  if (!ownsExistingCredential(existing, markerRaw, markerHashes)) {
     return { action: "skip", reason: "foreign-credentials" };
   }
-  const fresh = material.refresh ? existing.accessToken === material.access : existing.accessToken === material.access && typeof existing.expiresAt === "number" && existing.expiresAt > input.now + REFRESH_SKEW_MS;
-  if (fresh) return { action: "skip", reason: "current" };
-  return { action: "write", contents, marker };
+  if (cliRefreshedSameKey(input, material, existing, markerRaw)) {
+    return { action: "skip", reason: "current" };
+  }
+  if (!isCurrentCredential(existing, material, input.now)) {
+    return { action: "write", contents, marker };
+  }
+  return needsMarkerUpgrade(input, material) ? { action: "mark", marker } : { action: "skip", reason: "current" };
 }
-async function readRaw(path2) {
+
+// src/harness/pty/credentials.ts
+function claudeCredentialsPath() {
+  return join5(claudeConfigHome(), ".credentials.json");
+}
+function isConveyorCloudEnv(env = process.env) {
+  return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
+}
+async function readRaw(path) {
   try {
-    return await readFile(path2, "utf8");
+    return await readFile(path, "utf8");
   } catch {
     return null;
   }
@@ -4128,13 +4214,12 @@ async function resolveTuiAuthReadiness(env = process.env, readIdentity = readCre
   });
   return { ready: status === "ready", status };
 }
-async function readCredentialsIdentity() {
-  const parsed = parseClaudeAiOauth(await readRaw(claudeCredentialsPath()));
-  if (!parsed) return null;
-  return {
-    accessToken: typeof parsed.accessToken === "string" ? parsed.accessToken : null,
-    hasRefreshToken: typeof parsed.refreshToken === "string" && parsed.refreshToken.length > 0
-  };
+async function readCredentialsIdentity(env = process.env) {
+  return parseCredentialsIdentity(
+    await readRaw(claudeCredentialsPath()),
+    await readRaw(conveyorCredentialsMarkerPath()),
+    env.CONVEYOR_CODING_AGENT_KEY_ID
+  );
 }
 var READ_BACK_DELAYS_MS = [250, 500, 1e3, 2e3];
 var defaultSleep = (ms) => new Promise((resolve) => {
@@ -4149,10 +4234,10 @@ async function writeWithReadBackRetry(io, contents, delaysMs = READ_BACK_DELAYS_
     await sleep2(delaysMs[attempt]);
   }
 }
-function fsWriteIo(path2, mode) {
+function fsWriteIo(path, mode) {
   return {
-    write: (contents) => writeFile4(path2, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
-    read: () => readRaw(path2)
+    write: (contents) => writeFile4(path, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
+    read: () => readRaw(path)
   };
 }
 async function ensureClaudeCredentials(env = process.env) {
@@ -4164,27 +4249,29 @@ async function ensureClaudeCredentials(env = process.env) {
     await sanitizeApprovedApiKeys(accessToken);
   }
   try {
-    const path2 = claudeCredentialsPath();
+    const path = claudeCredentialsPath();
     const markerPath = conveyorCredentialsMarkerPath();
     const plan = planCredentialsWrite({
       isCloud,
       token,
       oauthBlob: env.CONVEYOR_CLAUDE_OAUTH,
-      existingRaw: await readRaw(path2),
+      existingRaw: await readRaw(path),
       markerRaw: await readRaw(markerPath),
+      codingAgentKeyId: env.CONVEYOR_CODING_AGENT_KEY_ID,
       now: Date.now()
     });
     if (plan.action === "skip") return;
     await mkdir2(claudeConfigHome(), { recursive: true });
     await writeWithReadBackRetry(fsWriteIo(markerPath, 384), plan.marker);
-    const verified = await writeWithReadBackRetry(fsWriteIo(path2, 384), plan.contents);
+    if (plan.action === "mark") return;
+    const verified = await writeWithReadBackRetry(fsWriteIo(path, 384), plan.contents);
     if (!verified) {
       process.stderr.write(
-        `[conveyor-agent] claude credentials read-back still stale after retries at ${path2} \u2014 TUI may land on the login picker
+        `[conveyor-agent] claude credentials read-back still stale after retries at ${path} \u2014 TUI may land on the login picker
 `
       );
     }
-    await chmod2(path2, 384).catch(() => {
+    await chmod2(path, 384).catch(() => {
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -4213,12 +4300,12 @@ function planApprovedApiKeyCleanup(existingRaw, oauthToken) {
 }
 async function sanitizeApprovedApiKeys(oauthToken) {
   try {
-    const path2 = claudeJsonPath();
-    const cleaned = planApprovedApiKeyCleanup(await readRaw(path2), oauthToken);
+    const path = claudeJsonPath();
+    const cleaned = planApprovedApiKeyCleanup(await readRaw(path), oauthToken);
     if (cleaned === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path2), cleaned);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path), 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 ${path2} \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 ${path} \u2014 CLI may still see the poisoned entry
 `
     );
   } catch (err) {
@@ -4355,8 +4442,8 @@ async function persistOauthIdentityMarker(configIdentity, markerIdentity) {
 async function ensureClaudeOnboarding(env = process.env, trustCwd) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path2 = claudeJsonPath();
-    const existingRaw = await readRaw(path2);
+    const path = claudeJsonPath();
+    const existingRaw = await readRaw(path);
     const markerIdentity = parseOauthIdentity(await readRaw(conveyorOauthMarkerPath()));
     await persistOauthIdentityMarker(
       extractOauthIdentity(parseClaudeJson(existingRaw)),
@@ -4364,16 +4451,16 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
     );
     const contents = planClaudeJsonSeed(existingRaw, trustCwd, markerIdentity);
     if (contents === null) return;
-    const verified = await writeWithReadBackRetry(fsWriteIo(path2), contents);
+    const verified = await writeWithReadBackRetry(fsWriteIo(path), contents);
     if (verified) {
       process.stderr.write(
         `[conveyor-agent] claude onboarding seeded${trustCwd ? ` (trust: ${trustCwd})` : ""}
 `
       );
     } else {
-      const verify = await readRaw(path2);
+      const verify = await readRaw(path);
       process.stderr.write(
-        `[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
+        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path} after retries: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
 `
       );
     }
@@ -4386,13 +4473,13 @@ async function ensureClaudeOnboarding(env = process.env, trustCwd) {
 async function removeConveyorCredentials(env = process.env) {
   try {
     if (!isConveyorCloudEnv(env)) return;
-    const path2 = claudeCredentialsPath();
+    const path = claudeCredentialsPath();
     const markerPath = conveyorCredentialsMarkerPath();
-    const existing = parseClaudeAiOauth(await readRaw(path2));
+    const existing = parseClaudeAiOauth(await readRaw(path));
     if (existing && !isConveyorOwnedCredentials(existing, parseCredentialsMarker(await readRaw(markerPath)))) {
       return;
     }
-    await rm(path2, { force: true });
+    await rm(path, { force: true });
     await rm(markerPath, { force: true });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -5901,10 +5988,10 @@ var TuiUnavailableError = class extends Error {
   }
   tui;
 };
-function isExecutable(path2) {
+function isExecutable(path) {
   try {
-    if (!statSync(path2).isFile()) return false;
-    accessSync(path2, constants.X_OK);
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, constants.X_OK);
     return true;
   } catch {
     return false;
@@ -5957,21 +6044,21 @@ function shouldSeed(existingEntry, seed) {
   if (typeof entry.expires !== "number") return true;
   return entry.expires < seed.expires;
 }
-async function readJsonFile(path2) {
+async function readJsonFile(path) {
   try {
-    return JSON.parse(await fs.readFile(path2, "utf8"));
+    return JSON.parse(await fs.readFile(path, "utf8"));
   } catch {
     return {};
   }
 }
-async function writeJsonFile(path2, value) {
-  await fs.mkdir(dirname2(path2), { recursive: true });
-  await fs.writeFile(path2, `${JSON.stringify(value, null, 2)}
+async function writeJsonFile(path, value) {
+  await fs.mkdir(dirname2(path), { recursive: true });
+  await fs.writeFile(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
 }
 async function ensureAuthEntry(env, seed) {
-  const path2 = opencodeAuthPath(env);
-  const store = await readJsonFile(path2);
+  const path = opencodeAuthPath(env);
+  const store = await readJsonFile(path);
   if (!shouldSeed(store.openai, seed)) {
     logger.info("opencode oauth store is fresher than the seed; leaving it alone");
     return;
@@ -5982,12 +6069,12 @@ async function ensureAuthEntry(env, seed) {
     refresh: seed.refresh,
     expires: seed.expires
   };
-  await writeJsonFile(path2, store);
+  await writeJsonFile(path, store);
   logger.info("seeded opencode oauth store entry");
 }
 async function ensurePluginConfig(env) {
-  const path2 = opencodeConfigPath(env);
-  const config = await readJsonFile(path2);
+  const path = opencodeConfigPath(env);
+  const config = await readJsonFile(path);
   const plugins = Array.isArray(config.plugin) ? config.plugin : [];
   const isOurs = (p) => typeof p === "string" && (p === PLUGIN_PACKAGE || p.startsWith(`${PLUGIN_PACKAGE}@`));
   const hasExactPin = plugins.includes(OPENCODE_CODEX_PLUGIN);
@@ -5995,7 +6082,7 @@ async function ensurePluginConfig(env) {
   if (hasExactPin && !hasStalePin) return;
   const kept = plugins.filter((p) => !isOurs(p));
   config.plugin = [...kept, OPENCODE_CODEX_PLUGIN];
-  await writeJsonFile(path2, config);
+  await writeJsonFile(path, config);
   logger.info("ensured opencode codex-auth plugin in config");
 }
 async function seedOpenCodeOauth(env) {
@@ -6217,9 +6304,9 @@ var OpenCodeHeadlessHarness = class {
    */
   async writeSystemPrompt(text) {
     if (!text || text.trim() === "") return null;
-    const path2 = join10(this.tempDir, "conveyor-instructions.md");
-    await writeFile6(path2, text, "utf8");
-    return path2;
+    const path = join10(this.tempDir, "conveyor-instructions.md");
+    await writeFile6(path, text, "utf8");
+    return path;
   }
   /**
    * Parse one NDJSON line and push whatever it maps to. Returns assistant text so
@@ -6682,7 +6769,7 @@ function wrapBridgeWithDirectStream(inner, reporter, options = {}) {
 
 // src/execution/query-executor.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync, readFileSync as readFileSync3, truncateSync } from "fs";
+import { existsSync, readFileSync as readFileSync2, truncateSync } from "fs";
 
 // src/execution/chat-instructions.ts
 function buildChatInstructions(context, scenario, newMessages) {
@@ -10460,9 +10547,9 @@ Paste this into the PR description to show it inline:
 ${snippet}`;
 }
 function buildUploadAttachmentTool(connection, config) {
-  return defineContractTool(uploadAttachmentContract, async ({ path: path2, title, tags }) => {
+  return defineContractTool(uploadAttachmentContract, async ({ path, title, tags }) => {
     try {
-      const filePath = isAbsolute(path2) ? path2 : join12(config.workspaceDir, path2);
+      const filePath = isAbsolute(path) ? path : join12(config.workspaceDir, path);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -12646,33 +12733,6 @@ function collectMissingProps(taskProps) {
   return missing;
 }
 
-// src/runner/heavy-gate.ts
-import { readFileSync as readFileSync2 } from "fs";
-import path from "path";
-var GATE_KEYS = ["heavy", "test", "typecheck", "build"];
-function runDir() {
-  return process.env.CONVEYOR_RUN_DIR ?? "/tmp/conveyor-run";
-}
-function pidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isHeavyGateActive() {
-  for (const key of GATE_KEYS) {
-    try {
-      const raw = readFileSync2(path.join(runDir(), `${key}.pid`), "utf8").trim();
-      const pid = Number.parseInt(raw, 10);
-      if (Number.isInteger(pid) && pid > 0 && pidAlive(pid)) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-
 // src/execution/tool-loop-tracker.ts
 var REPEAT_INTERRUPT_THRESHOLD = 4;
 var REPEAT_INTERRUPT_INTERVAL = 4;
@@ -13150,7 +13210,9 @@ function taskIdToSessionUuid(lineageKey) {
   return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-8${hash.slice(13, 16)}-a${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
 }
 function sessionLineageKey(taskId, agentMode, runnerMode) {
-  return agentMode === "review" || runnerMode === "code-review" ? `${taskId}:review` : taskId;
+  if (agentMode === "review" || runnerMode === "code-review") return `${taskId}:review`;
+  if (runnerMode === "plan") return `${taskId}:plan`;
+  return taskId;
 }
 function sessionFileExists(sessionUuid, cwd) {
   try {
@@ -13171,10 +13233,10 @@ function resolveSessionStart(lineageKey, cwd) {
   }
   return { sessionId: sessionUuid };
 }
-function repairTornSessionFile(path2) {
+function repairTornSessionFile(path) {
   try {
-    if (!existsSync(path2)) return false;
-    const content = readFileSync3(path2, "utf8");
+    if (!existsSync(path)) return false;
+    const content = readFileSync2(path, "utf8");
     if (content.length === 0) return false;
     let keepEnd = content.length;
     if (!content.endsWith("\n")) {
@@ -13193,9 +13255,9 @@ function repairTornSessionFile(path2) {
       keepEnd = prevNewline + 1;
     }
     if (keepEnd === content.length) return false;
-    truncateSync(path2, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
+    truncateSync(path, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
     logger5.warn("Repaired torn transcript before resume", {
-      path: path2,
+      path,
       trimmedBytes: content.length - keepEnd
     });
     return true;
@@ -13417,7 +13479,7 @@ async function handleTurnSilence(host, state, waitMs, silenceTimeoutMs, probeMou
     host,
     `[conveyor-agent] Turn produced no events for ${minutes}m with no heavy gate running \u2014 aborting the wedged turn
 `,
-    `Turn silent for ${minutes}m \u2014 aborting it so the agent can go idle (the conversation resumes on the next message)`
+    `Turn silent for ${minutes}m \u2014 aborting it so the agent can go idle. A first turn retries automatically; otherwise the conversation resumes on the next message.`
   );
   return "keep_waiting";
 }
@@ -14299,6 +14361,7 @@ var FIRST_SEND_MS = 5e3;
 var RESEND_INTERVAL_MS = 4e3;
 var MAX_SENDS = 5;
 var RENDER_SETTLE_MS = 900;
+var EMPTY_MCP_CONFIG = JSON.stringify({ mcpServers: {} });
 function buildProbeEnv(env = process.env) {
   const clean = {};
   for (const [key, value] of Object.entries(env)) {
@@ -14354,7 +14417,7 @@ var UsageProbeRun = class {
     this.settleTimer = setTimeout(() => this.finish(this.buf), this.timing.settleMs);
   }
   finishBestEffort() {
-    this.finish(panelRendering(this.buf) ? this.buf : "");
+    this.finish(panelRendering(this.buf) ? this.buf : cleanTerminalOutput(this.buf, 500));
   }
   finish(out) {
     if (this.settled) return;
@@ -14366,6 +14429,12 @@ var UsageProbeRun = class {
     this.resolve(out);
   }
 };
+function buildUsageProbeArgs() {
+  return ["--mcp-config", EMPTY_MCP_CONFIG, "--strict-mcp-config"];
+}
+function resolveUsageProbeCwd(explicitCwd, env = process.env) {
+  return explicitCwd ?? env.CONVEYOR_WORKSPACE ?? process.cwd();
+}
 async function runUsageProbe(deps = {}) {
   let spawn2 = deps.spawn;
   if (!spawn2) {
@@ -14376,7 +14445,8 @@ async function runUsageProbe(deps = {}) {
     }
   }
   const binary = deps.binary ?? resolveClaudeBinary();
-  const cwd = deps.cwd ?? process.cwd();
+  const baseEnv = deps.env ?? process.env;
+  const cwd = resolveUsageProbeCwd(deps.cwd, baseEnv);
   const timeoutMs = deps.timeoutMs ?? PROBE_TIMEOUT_MS;
   const timing = {
     firstSendMs: deps.firstSendMs ?? FIRST_SEND_MS,
@@ -14386,12 +14456,12 @@ async function runUsageProbe(deps = {}) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn2(binary, [], {
+      child = spawn2(binary, buildUsageProbeArgs(), {
         name: "xterm-256color",
         cols: 120,
         rows: 45,
         cwd,
-        env: buildProbeEnv(deps.env)
+        env: buildProbeEnv(baseEnv)
       });
     } catch {
       resolve("");
@@ -14406,10 +14476,10 @@ var logger7 = createServiceLogger("usage-sampler");
 var NO_SAMPLES = { samples: [], unmeasurable: null };
 function isAttributable(identity, sessionToken) {
   if (!identity) return { ok: true };
-  if (identity.hasRefreshToken) {
+  if (identity.hasRefreshToken && !identity.isConveyorOwned) {
     return { ok: false, reason: "manual-login-credentials" };
   }
-  if (sessionToken && identity.accessToken && identity.accessToken !== sessionToken) {
+  if (!(identity.hasRefreshToken && identity.isConveyorOwned) && sessionToken && identity.accessToken && identity.accessToken !== sessionToken) {
     return { ok: false, reason: "credentials-token-mismatch" };
   }
   return { ok: true };
@@ -14522,6 +14592,9 @@ async function handlePullBranch(workDir, branch) {
   }
 }
 
+// src/runner/session-runner.ts
+import { rmSync } from "fs";
+
 // src/runner/background-work.ts
 var BACKGROUND_WORK_MAX_MS = 45 * 60 * 1e3;
 var BACKGROUND_DEFAULT_BY_TOOL = {
@@ -14632,8 +14705,8 @@ function findLiveChild(sources) {
 
 // src/runner/session-runner.ts
 var AUTO_RUN_MODES = /* @__PURE__ */ new Set(["building", "auto", "review", "discovery", "chat"]);
-var AUTONOMOUS_RUNNER_MODES = /* @__PURE__ */ new Set(["pack", "pm", "code-review"]);
 var CHILD_DEFER_RECHECK_MS = 60 * 1e3;
+var ORPHAN_WAKE_GRACE_MS = 3 * 60 * 1e3;
 var SessionRunner = class _SessionRunner {
   connection;
   mode;
@@ -14703,9 +14776,11 @@ var SessionRunner = class _SessionRunner {
       onHeartbeat: () => {
         const loopStatus = this.refreshLoopStatus();
         this.connection.sendHeartbeat(this.loopLag.takeMaxLagMs(), loopStatus);
+        this.maybeWakeForOrphanedBackgroundWork();
       },
       onIdleTimeout: () => {
         if (this.deferShutdownForLiveChild("idle")) return;
+        if (this.deferShutdownForBackgroundWork()) return;
         process.stderr.write("[conveyor-agent] Idle timeout reached, stopping agent\n");
         this.stopped = true;
         this.queryBridge?.stop();
@@ -14786,6 +14861,133 @@ var SessionRunner = class _SessionRunner {
     }
     return true;
   }
+  /** Epoch ms of the first idle-shutdown deferral for background work in the
+   *  current idle episode; null when nothing has deferred. Reset when a turn
+   *  runs, so each idle episode gets its own bounded hold. */
+  backgroundDeferStartedAt = null;
+  /**
+   * Suppress an idle shutdown while backgrounded work (`run_in_background`
+   * launches tracked by `BackgroundWorkTracker`) or a live gate process
+   * (`isHeavyGateActive` — singleton pidfiles plus the `conveyor-gate`
+   * contract dir) is still running. Without this the 30-minute idle timeout
+   * stopped the runner mid-gate: `shutdown()` cleared the tracker, heartbeats
+   * stopped, the activity clock expired, and the reconciler slept the pod and
+   * reverted the card to Open.
+   *
+   * Bounded: deferrals past the first one cap at `BACKGROUND_WORK_MAX_MS`, so
+   * a wedged gate process cannot pin a pod forever. Only the IDLE timeout is
+   * deferred — post-`completed` dormancy keeps today's behavior, and a parked
+   * prefill (`waiting_for_input`) contributes nothing here, so those cards
+   * still sleep on the ordinary window.
+   */
+  deferShutdownForBackgroundWork() {
+    let holding = null;
+    try {
+      if (this.backgroundWork.hasPending()) holding = "background work outstanding";
+      else if (isHeavyGateActive()) holding = "a gate process is running";
+    } catch (err) {
+      process.stderr.write(`[conveyor-agent] Background-work probe failed, not deferring: ${err}
+`);
+      return false;
+    }
+    if (!holding) {
+      this.backgroundDeferStartedAt = null;
+      return false;
+    }
+    const now = Date.now();
+    this.backgroundDeferStartedAt ??= now;
+    if (now - this.backgroundDeferStartedAt >= BACKGROUND_WORK_MAX_MS) {
+      process.stderr.write(
+        `[conveyor-agent] Idle-shutdown deferral cap (${BACKGROUND_WORK_MAX_MS}ms) reached while ${holding} \u2014 proceeding with shutdown
+`
+      );
+      return false;
+    }
+    const recheckMs = Math.min(this.lifecycle.config.idleTimeoutMs, CHILD_DEFER_RECHECK_MS);
+    process.stderr.write(`[conveyor-agent] Idle timeout deferred: ${holding}
+`);
+    this.lifecycle.startIdleTimer(recheckMs);
+    return true;
+  }
+  /** When orphan evidence (tracked work pending, no live gate process) began
+   *  holding continuously; null while the evidence is absent. */
+  orphanGraceStartedAt = null;
+  /** One-shot latch: at most one watchdog wake per idle episode. Reset when a
+   *  turn runs. */
+  backgroundWakeFiredThisIdle = false;
+  /** When the current idle episode began — an exit sentinel older than this
+   *  appeared while a turn could still have consumed it, so it never wakes. */
+  idleEpisodeStartedAt = 0;
+  /**
+   * Wake a parked agent whose background work finished — or died — without a
+   * consumed completion callback. Completion normally arrives as the CLI's
+   * `<task-notification>` transcript record; when that record is lost (SDK
+   * harness, torn transcript, a gate killed out from under the CLI) the
+   * tracker entry silently expires and the agent waits forever.
+   *
+   * This is NOT the removed auto-mode stuck-nudge: it fires only on positive
+   * evidence of orphaned background work — a tracked launch with no live gate
+   * process continuously past `ORPHAN_WAKE_GRACE_MS`, or an unconsumed
+   * `gates/<label>.exit` sentinel that appeared this idle episode — never on
+   * "the agent seems stuck". A `completed` agent is never woken (the
+   * completion guard holds), and a live pid always suppresses the wake.
+   */
+  maybeWakeForOrphanedBackgroundWork() {
+    try {
+      if (this._state !== "idle" || this.stopped || this.completedThisTurn) {
+        this.orphanGraceStartedAt = null;
+        return;
+      }
+      if (this.backgroundWakeFiredThisIdle) return;
+      if (!this.inputResolver) return;
+      if (isHeavyGateActive()) {
+        this.orphanGraceStartedAt = null;
+        return;
+      }
+      const evidence = this.findOrphanEvidence(Date.now());
+      if (!evidence) return;
+      process.stderr.write(
+        `[conveyor-agent] Background-work watchdog: waking agent \u2014 ${evidence.description}
+`
+      );
+      this.backgroundWakeFiredThisIdle = true;
+      this.orphanGraceStartedAt = null;
+      if (evidence.sentinel) rmSync(evidence.sentinel.path, { force: true });
+      this.backgroundWork.clear();
+      const resolver = this.inputResolver;
+      this.inputResolver = null;
+      resolver({
+        content: `A background job you started appears to have finished or died without delivering its completion notification (${evidence.description}). Read the job's output \u2014 its log file, or the corresponding file under $CONVEYOR_RUN_DIR/gates/ \u2014 to determine the real result, then continue your plan. Do not assume the job succeeded; verify its output first, and rerun it if it was killed.`,
+        userId: "system",
+        source: "background_work_check"
+      });
+    } catch (err) {
+      process.stderr.write(`[conveyor-agent] Background-work watchdog probe failed: ${err}
+`);
+    }
+  }
+  /** Orphan evidence that has held past the grace, or null. Maintains the
+   *  grace clock for the tracked-work condition as a side effect. */
+  findOrphanEvidence(now) {
+    const sentinel = listGateExitSentinels().find(
+      (s) => s.mtimeMs >= this.idleEpisodeStartedAt && now - s.mtimeMs >= ORPHAN_WAKE_GRACE_MS
+    );
+    if (sentinel) {
+      return {
+        sentinel,
+        description: `gate '${sentinel.label}' finished (exit ${sentinel.code ?? "unknown"}) with its completion never consumed`
+      };
+    }
+    if (!this.backgroundWork.hasPending()) {
+      this.orphanGraceStartedAt = null;
+      return null;
+    }
+    this.orphanGraceStartedAt ??= now;
+    if (now - this.orphanGraceStartedAt < ORPHAN_WAKE_GRACE_MS) return null;
+    return {
+      description: `${this.backgroundWork.pendingCount()} tracked background launch(es) with no live gate process for ${Math.round(ORPHAN_WAKE_GRACE_MS / 6e4)}+ minutes`
+    };
+  }
   get sessionId() {
     return this.connection.sessionId;
   }
@@ -15113,26 +15315,48 @@ var SessionRunner = class _SessionRunner {
     return true;
   }
   /**
-   * The mid-turn wedge watchdog aborts a turn that produced no events for 30
-   * minutes. Its documented recovery — "the next message respawns with
-   * `--resume`" — assumes a human or a follow-up is coming, which is exactly
-   * what an autonomous card does NOT have: after the abort the runner goes
-   * idle and the card parks until a pack watchdog or a human notices.
+   * The mid-turn watchdog aborts a turn that produced no events for 30 minutes
+   * (or one whose config-home mount died). Its documented recovery — "the next
+   * message respawns with `--resume`" — assumes a human or a follow-up is
+   * coming. A KICKOFF turn has neither by construction: it is the turn that
+   * starts the conversation, so there is no next message, and the runner goes
+   * idle with the card parked until a human notices.
+   *
+   * Observed live 2026-08-28 (card cmtd78iql): a spawned builder child's
+   * kickoff turn produced nothing for 30 minutes, was aborted, and the child
+   * then heartbeated idle for another 43 minutes until a human typed
+   * "@[agent:builder] continue".
+   *
+   * So any submit-delivery INITIAL query killed by the watchdog is re-run once
+   * against the (durable, on-disk) resumed session. Bounded to a single retry:
+   * a second wedge is a real failure that should surface as a parked card
+   * rather than loop the pod.
+   *
+   * Nothing recovers a card from there automatically, and that is the honest
+   * state of it. The server's session sweep does NOT catch this shape: its
+   * predicate is `agentRunningAt` still null, and a turn that started and then
+   * wedged has already stamped it. The sweep covers a builder that never took a
+   * turn at all; this retry covers one whose first turn stalled. Twice-wedged
+   * needs a human, and a card left that way keeps its Builder tab and its
+   * heartbeat, so it is visible rather than silently gone.
+   *
+   * Skipped when a pending message already exists, because the core loop
+   * delivers that instead, which is the path the watchdog's original recovery
+   * assumed.
    *
-   * So for an autonomous card whose INITIAL query was killed as wedged, re-run
-   * that initial query once against the (durable, on-disk) resumed session.
-   * Bounded to a single retry: a second wedge is a real failure that should
-   * surface as a parked card rather than loop the pod. Skipped when a pending
-   * message already exists — the core loop delivers that instead, which is the
-   * path the watchdog's original recovery assumed.
+   * A mount-death abort retries too, and must: the repair for a dead config
+   * home is the respawn that follows the abort, so a kickoff with nothing
+   * behind it would otherwise never get one.
+   *
+   * NOT for follow-up turns — there "the conversation resumes on the next
+   * message" is exactly right.
    */
   async requeueWedgedInitialQuery(delivery) {
     if (!this.queryBridge?.lastTurnWedgeAborted) return;
     if (this.stopped || this.interrupted || this.completedThisTurn) return;
     if (this.pendingMessages.length > 0) return;
-    if (!this.mode.isAuto && !AUTONOMOUS_RUNNER_MODES.has(this.config.runnerMode ?? "")) return;
     process.stderr.write(
-      "[conveyor-agent] Initial query was aborted as wedged with nothing queued behind it \u2014 re-running it once (an autonomous card has no follow-up message coming)\n"
+      "[conveyor-agent] Initial query was aborted as wedged with nothing queued behind it \u2014 re-running it once (a kickoff turn has no follow-up message coming)\n"
     );
     this.connection.sendEvent({
       type: "error",
@@ -15373,7 +15597,10 @@ var SessionRunner = class _SessionRunner {
   async sampleAndReportKeyUsage() {
     if (this.stopped) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
-    const { samples, unmeasurable } = await sampleKeyUsage(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    const { samples, unmeasurable } = await sampleKeyUsage(
+      process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      () => runUsageProbe({ cwd: this.config.workspaceDir })
+    );
     if (unmeasurable) {
       this.connection.sendEvent(buildUnmeasurableEvent(unmeasurable.reason, codingAgentKeyId));
       return;
@@ -15685,7 +15912,7 @@ ${outcome.failures.join("\n")}
    */
   resolveLoopStatus() {
     if (loopStatusForRunnerStatus(this._state) === "active") return "active";
-    return this.backgroundWork.hasPending() ? "waiting" : "idle";
+    return this.backgroundWork.hasPending() || isHeavyGateActive() ? "waiting" : "idle";
   }
   /** Mirror the resolved status into the loop-lag buffer so the starvation-proof
    *  heartbeat worker reports it too. Returns what it wrote. */
@@ -15701,6 +15928,11 @@ ${outcome.failures.join("\n")}
     this.backgroundWork.noteToolUse(event.tool, event.input);
   }
   async setState(status) {
+    if (status === "running") {
+      this.backgroundDeferStartedAt = null;
+      this.backgroundWakeFiredThisIdle = false;
+    }
+    if (status === "idle" && this._state !== "idle") this.idleEpisodeStartedAt = Date.now();
     this._state = status;
     this.refreshLoopStatus();
     await this.connection.emitStatus(status);
@@ -15730,6 +15962,15 @@ ${outcome.failures.join("\n")}
   get finalState() {
     return this._finalState;
   }
+  /** Does a transcript already exist for this session's lineage? */
+  resolvesToTranscriptResume() {
+    const taskId = this.fullContext?.taskId;
+    if (!taskId) return false;
+    return hasExistingSessionFile(taskId, this.config.workspaceDir, {
+      agentMode: this.mode.effectiveMode,
+      runnerMode: this.config.runnerMode
+    });
+  }
   buildTaskContextSnapshot() {
     return {
       isParentTask: this.fullContext?.isParentTask ?? false,
@@ -15746,6 +15987,12 @@ ${outcome.failures.join("\n")}
       mode: this.mode.effectiveMode,
       runnerMode: this.config.runnerMode ?? "task",
       sessionId: this.sessionId,
+      // Whether this run will RESUME a transcript, read from disk under this
+      // session's own lineage. `hasExistingSession` below answers a different
+      // question — does the server hold an sdkSessionId — and the two disagree
+      // whenever a role's lineage is fresh. Resume is filesystem-driven, so
+      // this is the field to read when a session's context looks wrong.
+      resumesTranscript: this.resolvesToTranscriptResume(),
       ...this.buildTaskContextSnapshot(),
       model: this.taskContext?.model,
       isAuto: this.config.isAuto ?? false,