@rallycry/conveyor-agent 10.13.69 → 10.13.71

package/dist/{boot-7UWVK777.js → boot-PKHZUDAC.js}

@@ -490,7 +490,108 @@ import {
   symlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
+
+// src/boot/memory-integrity.ts
+import { readFile, readdir, stat, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+var FRONTMATTER_OPEN = "---\n";
+var FRONTMATTER_CLOSE = "\n---\n";
+var MAX_MEMORY_FILE_BYTES = 512 * 1024;
+var READ_CONCURRENCY = 16;
+function readFrontmatterBlock(content) {
+  if (!content.startsWith(FRONTMATTER_OPEN)) return null;
+  const close = content.indexOf(FRONTMATTER_CLOSE, FRONTMATTER_OPEN.length - 1);
+  if (close === -1) return null;
+  return content.slice(0, close + FRONTMATTER_CLOSE.length);
+}
+function inspectMemoryFile(content) {
+  const header = readFrontmatterBlock(content);
+  if (!header) return { status: "clean" };
+  const repeat = content.indexOf(header, header.length);
+  if (repeat === -1) return { status: "clean" };
+  const half = content.length / 2;
+  if (repeat === half && content.slice(0, half) === content.slice(half)) {
+    return { status: "self-append", repaired: content.slice(0, half) };
+  }
+  return {
+    status: "suspicious",
+    detail: `frontmatter block repeats at offset ${repeat} of ${content.length} without identical halves`
+  };
+}
+async function candidateSize(path) {
+  try {
+    const info = await stat(path);
+    if (!info.isFile() || info.size === 0) return null;
+    if (info.size > MAX_MEMORY_FILE_BYTES || info.size % 2 !== 0) return null;
+    return info.size;
+  } catch {
+    return null;
+  }
+}
+async function repairOneFile(dir, name, log, out) {
+  const path = join2(dir, name);
+  const size = await candidateSize(path);
+  if (size === null) {
+    out.skipped += 1;
+    return;
+  }
+  out.scanned += 1;
+  const verdict = inspectMemoryFile(await readFile(path, "utf8"));
+  if (verdict.status === "suspicious") {
+    out.suspicious.push(name);
+    log.warn(
+      `[boot] WARN shared memory ${name} looks doubled but was left alone: ${verdict.detail}`
+    );
+    return;
+  }
+  if (verdict.status !== "self-append" || verdict.repaired === void 0) return;
+  if (await candidateSize(path) !== size) {
+    log.warn(`[boot] WARN shared memory ${name} changed mid-check; left alone`);
+    return;
+  }
+  await writeFile(path, verdict.repaired);
+  out.repaired.push(name);
+}
+async function forEachLimited(items, limit, fn) {
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    for (let i = cursor++; i < items.length; i = cursor++) {
+      const item = items[i];
+      if (item !== void 0) await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
+async function repairSharedMemory(dir, log) {
+  const out = { scanned: 0, repaired: [], suspicious: [], skipped: 0 };
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return out;
+  }
+  const names = entries.filter((name) => name.endsWith(".md"));
+  await forEachLimited(names, READ_CONCURRENCY, async (name) => {
+    try {
+      await repairOneFile(dir, name, log, out);
+    } catch (err) {
+      log.warn(
+        `[boot] WARN shared memory integrity check failed for ${name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  });
+  out.repaired.sort();
+  out.suspicious.sort();
+  if (out.repaired.length > 0) {
+    log.info(
+      `[boot] shared memory: repaired ${out.repaired.length} self-appended file(s): ${out.repaired.join(", ")}`
+    );
+  }
+  return out;
+}
+
+// src/boot/user-home.ts
 var SEED_GATES = {
   hasCompletedOnboarding: true,
   bypassPermissionsModeAccepted: true,
@@ -566,8 +667,8 @@ function relink(target, link) {
 }
 function wireCredentials(opts) {
   const { home, root, sharedDir, log } = opts;
-  const shared = join2(root, ".claude", ".credentials.json");
-  const podLocal = sharedDir ? join2(sharedDir, "claude-credentials.pod.json") : join2(home, ".claude-credentials.pod.json");
+  const shared = join3(root, ".claude", ".credentials.json");
+  const podLocal = sharedDir ? join3(sharedDir, "claude-credentials.pod.json") : join3(home, ".claude-credentials.pod.json");
   safely(log, "carry legacy shared credentials", () => {
     if (isRegularFile(shared)) copyFileSync(shared, podLocal);
   });
@@ -583,66 +684,78 @@ function migrateMemories(from, to, log) {
     return;
   }
   for (const entry of entries) {
-    const target = join2(to, entry);
+    const target = join3(to, entry);
     if (existsSync(target)) continue;
-    safely(log, `migrate memory ${entry}`, () => copyFileSync(join2(from, entry), target));
+    safely(log, `migrate memory ${entry}`, () => copyFileSync(join3(from, entry), target));
   }
 }
+function startSharedMemoryRepair(shared, log) {
+  return repairSharedMemory(shared, log).then(
+    () => void 0,
+    (err) => {
+      log.warn(
+        `[boot] WARN repair self-appended shared memories failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  );
+}
 function wireSharedMemory(root, userHomeMount, projectId, log) {
-  const shared = join2(userHomeMount, "users", "_shared", "memory", projectId);
-  const link = join2(root, ".claude", "projects", AGENT_MEMORY_PROJECT_DIR, "memory");
+  const shared = join3(userHomeMount, "users", "_shared", "memory", projectId);
+  const link = join3(root, ".claude", "projects", AGENT_MEMORY_PROJECT_DIR, "memory");
   safely(log, "mkdir shared memory dir", () => mkdirSync(shared, { recursive: true }));
   safely(log, "migrate per-user memories", () => {
     if (existsSync(link) && !lstatSync(link).isSymbolicLink()) migrateMemories(link, shared, log);
   });
   safely(log, "wire shared memory symlink", () => relink(shared, link));
+  return startSharedMemoryRepair(shared, log);
 }
 function wireMountedUserHome(opts) {
   const { home, userHomeMount, userId, projectId, sharedDir, log } = opts;
-  const root = join2(userHomeMount, "users", userId, projectId);
+  const root = join3(userHomeMount, "users", userId, projectId);
   safely(log, "mkdir user-home root", () => {
-    mkdirSync(join2(root, ".claude"), { recursive: true });
-    mkdirSync(join2(root, ".config", "claude"), { recursive: true });
+    mkdirSync(join3(root, ".claude"), { recursive: true });
+    mkdirSync(join3(root, ".config", "claude"), { recursive: true });
   });
-  safely(log, "wire ~/.claude symlink", () => relink(join2(root, ".claude"), join2(home, ".claude")));
+  safely(log, "wire ~/.claude symlink", () => relink(join3(root, ".claude"), join3(home, ".claude")));
   safely(
     log,
     "wire ~/.config/claude symlink",
-    () => relink(join2(root, ".config", "claude"), join2(home, ".config", "claude"))
+    () => relink(join3(root, ".config", "claude"), join3(home, ".config", "claude"))
   );
   safely(log, "seed pod-local ~/.claude.json", () => {
-    rmSync(join2(home, ".claude.json"), { recursive: true, force: true });
-    seedClaudeJson(join2(home, ".claude.json"));
+    rmSync(join3(home, ".claude.json"), { recursive: true, force: true });
+    seedClaudeJson(join3(home, ".claude.json"));
   });
-  wireSharedMemory(root, userHomeMount, projectId, log);
+  const pendingRepair = wireSharedMemory(root, userHomeMount, projectId, log);
   wireCredentials({ home, root, sharedDir, log });
   safely(log, "mkdir opencode root", () => {
-    mkdirSync(join2(root, ".local", "share", "opencode"), { recursive: true });
-    mkdirSync(join2(root, ".config", "opencode"), { recursive: true });
+    mkdirSync(join3(root, ".local", "share", "opencode"), { recursive: true });
+    mkdirSync(join3(root, ".config", "opencode"), { recursive: true });
   });
   safely(
     log,
     "wire opencode data symlink",
-    () => relink(join2(root, ".local", "share", "opencode"), join2(home, ".local", "share", "opencode"))
+    () => relink(join3(root, ".local", "share", "opencode"), join3(home, ".local", "share", "opencode"))
   );
   safely(
     log,
     "wire opencode config symlink",
-    () => relink(join2(root, ".config", "opencode"), join2(home, ".config", "opencode"))
+    () => relink(join3(root, ".config", "opencode"), join3(home, ".config", "opencode"))
   );
+  return pendingRepair;
 }
 function wireNoMountUserHome(opts) {
   const { home, sharedDir, log } = opts;
   safely(
     log,
     "seed pod-local ~/.claude.json (no mount)",
-    () => seedClaudeJson(join2(home, ".claude.json"))
+    () => seedClaudeJson(join3(home, ".claude.json"))
   );
   if (sharedDir) {
     safely(log, "wire ~/.claude to shared emptyDir", () => {
-      const target = join2(sharedDir, "claude-home", ".claude");
+      const target = join3(sharedDir, "claude-home", ".claude");
       mkdirSync(target, { recursive: true });
-      relink(target, join2(home, ".claude"));
+      relink(target, join3(home, ".claude"));
     });
   }
 }
@@ -654,14 +767,14 @@ function wireUserHome(opts) {
     () => mkdirSync(opts.scratchDir ?? "/tmp/claude-cmd", { recursive: true })
   );
   if (userId && projectId && isDir(userHomeMount)) {
-    wireMountedUserHome({ home, userHomeMount, userId, projectId, sharedDir, log });
-  } else {
-    wireNoMountUserHome({ home, sharedDir, log });
+    return wireMountedUserHome({ home, userHomeMount, userId, projectId, sharedDir, log });
   }
+  wireNoMountUserHome({ home, sharedDir, log });
+  return Promise.resolve();
 }
 var RECLAIM_FIND_TIMEOUT_MS = 1e4;
 async function reclaimHomeOwnership(home, exec, log) {
-  for (const dir of [join2(home, ".config"), join2(home, ".local")]) {
+  for (const dir of [join3(home, ".config"), join3(home, ".local")]) {
     if (!isDir(dir)) continue;
     try {
       await exec(
@@ -691,9 +804,9 @@ async function reclaimHomeOwnership(home, exec, log) {
 
 // src/boot/sshd.ts
 import { chmodSync as chmodSync2, closeSync, copyFileSync as copyFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function persistedAuthorizedKeys() {
-  return join3(
+  return join4(
     process.env.CONVEYOR_SHARED_DIR || "/var/run/conveyor-workbench",
     "ssh",
     "authorized_keys"
@@ -701,10 +814,10 @@ function persistedAuthorizedKeys() {
 }
 async function startWorkspaceSshd(exec, log, port = process.env.CONVEYOR_WORKSPACE_SSH_PORT || "2222", home = "/home/conveyor") {
   try {
-    const sshDir = join3(home, ".ssh");
+    const sshDir = join4(home, ".ssh");
     mkdirSync2(sshDir, { recursive: true });
     chmodSync2(sshDir, 448);
-    const authorizedKeys = join3(sshDir, "authorized_keys");
+    const authorizedKeys = join4(sshDir, "authorized_keys");
     const persisted = persistedAuthorizedKeys();
     if (existsSync2(persisted)) {
       copyFileSync2(persisted, authorizedKeys);
@@ -746,7 +859,7 @@ import {
   statSync as statSync3,
   symlinkSync as symlinkSync2
 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function errText(err) {
   return redactToken(err instanceof Error ? err.message : String(err));
 }
@@ -782,7 +895,7 @@ function bindGraphifyBundle(workspace, graphifyEnv, log) {
     log.info(`[boot] Graphify bundle not found for '${slug}' at ${sourceDir}`);
     return;
   }
-  const targetDir = join4(workspace, "graphify-out");
+  const targetDir = join5(workspace, "graphify-out");
   try {
     mkdirSync3(targetDir, { recursive: true });
   } catch {
@@ -790,8 +903,8 @@ function bindGraphifyBundle(workspace, graphifyEnv, log) {
     return;
   }
   for (const rel of GRAPHIFY_BUNDLE_FILES) {
-    const source = join4(sourceDir, rel);
-    const target = join4(targetDir, rel);
+    const source = join5(sourceDir, rel);
+    const target = join5(targetDir, rel);
     if (!existsSync3(source)) continue;
     if (existsSync3(target) || isSymlink(target)) continue;
     try {
@@ -803,7 +916,7 @@ function bindGraphifyBundle(workspace, graphifyEnv, log) {
 }
 async function ensureGrimoireSubmodule(workspace, githubToken, git, log) {
   try {
-    if (!existsSync3(join4(workspace, ".gitmodules"))) return;
+    if (!existsSync3(join5(workspace, ".gitmodules"))) return;
     let paths = "";
     try {
       ({ stdout: paths } = await git(
@@ -814,7 +927,7 @@ async function ensureGrimoireSubmodule(workspace, githubToken, git, log) {
       return;
     }
     if (!paths.split("\n").some((line) => line.trim().endsWith(".claude/grimoire"))) return;
-    if (isDir2(join4(workspace, ".claude", "grimoire", "skills"))) return;
+    if (isDir2(join5(workspace, ".claude", "grimoire", "skills"))) return;
     if (!githubToken) {
       log.warn("[boot] WARN: grimoire submodule absent and no token to fetch it");
       return;
@@ -843,11 +956,11 @@ async function ensureGrimoireSubmodule(workspace, githubToken, git, log) {
 }
 function excludeLinkedSkills(workspace, names, log) {
   if (names.length === 0) return;
-  const infoDir = join4(workspace, ".git", "info");
-  if (!isDir2(join4(workspace, ".git"))) return;
+  const infoDir = join5(workspace, ".git", "info");
+  if (!isDir2(join5(workspace, ".git"))) return;
   try {
     mkdirSync3(infoDir, { recursive: true });
-    const excludePath = join4(infoDir, "exclude");
+    const excludePath = join5(infoDir, "exclude");
     const existing = existsSync3(excludePath) ? readFileSync2(excludePath, "utf8") : "";
     const missing = names.map((name) => `.claude/skills/${name}`).filter((line) => !existing.split("\n").includes(line));
     if (missing.length === 0) return;
@@ -860,14 +973,14 @@ function excludeLinkedSkills(workspace, names, log) {
 }
 function symlinkTargetsGrimoire(path) {
   try {
-    return readlinkSync(path).includes(join4("grimoire", "skills"));
+    return readlinkSync(path).includes(join5("grimoire", "skills"));
   } catch {
     return false;
   }
 }
 function linkGrimoireSkills(workspace, log) {
-  const sourceDir = join4(workspace, ".claude", "grimoire", "skills");
-  const targetDir = join4(workspace, ".claude", "skills");
+  const sourceDir = join5(workspace, ".claude", "grimoire", "skills");
+  const targetDir = join5(workspace, ".claude", "skills");
   if (!isDir2(sourceDir)) return;
   try {
     mkdirSync3(targetDir, { recursive: true });
@@ -883,8 +996,8 @@ function linkGrimoireSkills(workspace, log) {
     return;
   }
   for (const name of names) {
-    if (!isDir2(join4(sourceDir, name))) continue;
-    const target = join4(targetDir, name);
+    if (!isDir2(join5(sourceDir, name))) continue;
+    const target = join5(targetDir, name);
     if (existsSync3(target) && !isSymlink(target)) {
       log.warn(`[boot] WARN: ${target} exists and is not a symlink; skipping`);
       continue;
@@ -892,7 +1005,7 @@ function linkGrimoireSkills(workspace, log) {
     if (isSymlink(target) && !symlinkTargetsGrimoire(target)) continue;
     try {
       rmSync2(target, { force: true });
-      symlinkSync2(join4("..", "grimoire", "skills", name), target);
+      symlinkSync2(join5("..", "grimoire", "skills", name), target);
       linkedNames.push(name);
     } catch {
     }
@@ -901,7 +1014,7 @@ function linkGrimoireSkills(workspace, log) {
   log.info(`[boot] Linked ${linkedNames.length} grimoire skills into ${targetDir}`);
 }
 async function neutralizeGrimoirePointer(workspace, git, log) {
-  if (!existsSync3(join4(workspace, ".claude", "grimoire"))) return;
+  if (!existsSync3(join5(workspace, ".claude", "grimoire"))) return;
   try {
     await git(["update-index", "--assume-unchanged", ".claude/grimoire"], {
       cwd: workspace,
@@ -953,8 +1066,8 @@ async function cloneReferenceRepos(refsJson, git, log, referencesDir = "/workspa
     return;
   }
   for (const ref of refs) {
-    const dest = join4(referencesDir, ref.slug);
-    if (existsSync3(join4(dest, ".git"))) continue;
+    const dest = join5(referencesDir, ref.slug);
+    if (existsSync3(join5(dest, ".git"))) continue;
     try {
       await git(
         [
@@ -1024,7 +1137,7 @@ function defaultWorkbenchBootDeps() {
       ctx.log.info(`[boot] ensured workspace dir ${WORKSPACE_DIR}`);
     },
     wireHome: (ctx) => {
-      wireUserHome({
+      void wireUserHome({
         home: HOME_DIR,
         userHomeMount: USER_HOME_MOUNT2,
         userId: ctx.childEnv?.CONVEYOR_USER_ID,
@@ -1183,7 +1296,7 @@ function agentBootSteps(deps = defaultBootDeps(), signal = new AbortController()
       critical: true,
       run: (ctx) => {
         if (ctx.bundle) {
-          wireUserHome({
+          void wireUserHome({
             home: HOME_DIR2,
             userHomeMount: USER_HOME_MOUNT3,
             userId: ctx.childEnv?.CONVEYOR_USER_ID,

package/dist/{chunk-2KZV6I5Z.js → chunk-7MMECTTJ.js}

@@ -1613,6 +1613,18 @@ async function hasUnpushedCommits(cwd) {
     return false;
   }
 }
+async function remoteMatchesLocalHead(cwd, branch) {
+  try {
+    const [remote, local] = await Promise.all([
+      git(cwd, ["ls-remote", "origin", `refs/heads/${branch}`], GIT_SLOW_TIMEOUT_MS),
+      git(cwd, ["rev-parse", "HEAD"])
+    ]);
+    const remoteSha = remote.split(/\s+/)[0] ?? "";
+    return /^[0-9a-f]{40}$/i.test(remoteSha) && remoteSha === local.trim();
+  } catch {
+    return false;
+  }
+}
 async function stageAndCommit(cwd, message) {
   try {
     await git(cwd, ["add", "-A"], GIT_SLOW_TIMEOUT_MS);
@@ -2029,7 +2041,8 @@ var projectCheckpointSettingsSchema = z.object({
   finalizeCommand: z.string().trim().min(1),
   credentialEpoch: z.string().trim().min(1),
   requiredSecretNames: uniqueSortedArray(secretNameSchema).optional(),
-  optionalSecretNames: uniqueSortedArray(secretNameSchema).optional()
+  optionalSecretNames: uniqueSortedArray(secretNameSchema).optional(),
+  bakeWebAppBuild: z.boolean().optional()
 }).superRefine((checkpoint, ctx) => {
   const required = new Set(checkpoint.requiredSecretNames ?? []);
   for (const name of checkpoint.optionalSecretNames ?? []) {
@@ -2279,7 +2292,15 @@ var PostToChatInputSchema = z4.object({
 });
 var GetTaskContextRequestSchema = z4.object({
   sessionId: z4.string(),
-  includeHistory: z4.boolean().optional().default(false)
+  includeHistory: z4.boolean().optional().default(false),
+  /**
+   * Read the plan-revised marker WITHOUT consuming it. Bookkeeping fetches
+   * (the session-identity check, the branch refresh) pass true so they cannot
+   * race the boot fetch and swallow the notice before it reaches the prompt.
+   * Defaults to false — consuming — so a pod running an older agent build still
+   * clears the marker instead of showing the notice on every boot forever.
+   */
+  peekPlanRevision: z4.boolean().optional().default(false)
 });
 var GetChatMessagesRequestSchema = z4.object({
   sessionId: z4.string(),
@@ -3844,6 +3865,17 @@ var PRE_BUILD_TASK_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
 function hasTaskPlan(plan) {
   return !!plan?.trim();
 }
+var CARD_TYPE_SURFACE = {
+  task: "board",
+  chat: "board",
+  incident: "report",
+  suggestion: "report"
+};
+var surfaceTypes = (surface) => Object.keys(CARD_TYPE_SURFACE).filter(
+  (type) => CARD_TYPE_SURFACE[type] === surface
+);
+var BOARD_CARD_TYPES = surfaceTypes("board");
+var REPORT_CARD_TYPES = surfaceTypes("report");
 
 // src/runner/mode-controller.ts
 var ModeController = class {
@@ -8343,7 +8375,7 @@ function wrapBridgeWithDirectStream(inner, reporter, options = {}) {
 
 // src/execution/query-executor.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2, truncateSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3, truncateSync } from "fs";
 
 // src/execution/chat-instructions.ts
 function buildChatInstructions(context, scenario, newMessages) {
@@ -8603,6 +8635,36 @@ After addressing the feedback, resume your autonomous loop: call list_subtasks a
   return parts;
 }
 
+// src/execution/plan-revision-notice.ts
+var MINUTE_MS = 60 * 1e3;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+function describeAge(revisedAt, now) {
+  const at = Date.parse(revisedAt);
+  if (Number.isNaN(at)) return "";
+  const ago = now - at;
+  if (ago < MINUTE_MS) return "just now";
+  if (ago < HOUR_MS) return `${Math.round(ago / MINUTE_MS)} minutes ago`;
+  if (ago < DAY_MS) return `${Math.round(ago / HOUR_MS)} hours ago`;
+  return `${Math.round(ago / DAY_MS)} days ago`;
+}
+function buildPlanRevisionNotice(context, now = Date.now()) {
+  const revisedAt = context.planRevisedAt;
+  if (!revisedAt) return [];
+  const age = describeAge(revisedAt, now);
+  const when = age ? `${age} (${revisedAt})` : revisedAt;
+  return [
+    `
+## \u26A0\uFE0F The plan changed since this build was dispatched`,
+    `Someone revised this card's plan ${when}. It was NOT you \u2014 an agent is never told about its own plan edit.`,
+    `Before your next Write or Edit:`,
+    `1. Call \`get_current_plan\` and read the current plan in full.`,
+    `2. Compare it against the plan you were launched with. Treat the current plan as the truth.`,
+    `3. Drop or redo any work the revision supersedes. Do NOT keep building the old plan.`,
+    `If the revision invalidates work you already committed, say so with post_to_chat before you continue.`
+  ];
+}
+
 // src/execution/prompt-formatters.ts
 function baseDiffCommand(baseBranch, flags) {
   const base = baseBranch ?? "dev";
@@ -8612,7 +8674,7 @@ function baseDiffCommand(baseBranch, flags) {
 function gateFailureModes() {
   return [
     `Reading a gate result correctly is what keeps this to ONE pass:`,
-    `- Capture the exit code explicitly (\`<gate> > <log> 2>&1; echo "EXIT:$?" >> <log>\`) \u2014 piping a gate through \`tail\` masks it. That \`EXIT:\` line, plus turbo's final \`Tasks:\` count, is the authority on pass/fail.`,
+    `- Capture AND propagate the exit code (\`<gate> > <log> 2>&1; ec=$?; echo "EXIT:$ec" >> <log>; (exit $ec)\`) \u2014 piping a gate through \`tail\` masks it, and a bare trailing \`echo "EXIT:$?"\` makes the wrapper exit 0 over a failed gate. That \`EXIT:\` line, plus turbo's final \`Tasks:\` count, is the authority on pass/fail.`,
     `- A green gate that printed no per-suite summary (no \`Test Files\`/\`Tests\` line) is still green: \`turbo.json\` sets \`outputLogs: "errors-only"\`, so a PASSING run prints nothing per suite. Do NOT re-run a clean-exit gate to "see the counts" \u2014 if you genuinely need them, run one package's script directly (\`bun run --cwd <pkg> test\`).`,
     `- Exit 143, or \`singleton: stopping running '<label>'\` on stderr, means a second gate you started evicted this one (on a pod the heavy gates share one lock). 143 is never a pass \u2014 but an evicted run never finished, so re-running it alone is still your one pass, not a repeat. Run one gate at a time; \`bun run check\` is not lock-wrapped, so it is safe alongside a test run.`,
     `- Confirm every package your diff touches actually appears in the run. \`--affected\` can select nothing for a package you changed; when that happens run just that package's suite directly, e.g. \`bun run --cwd apps/api test:unit <changed test files>\` \u2014 not the whole gate again.`,
@@ -8625,7 +8687,7 @@ function gateWaitProtocol() {
     `- Launch it ONCE with \`run_in_background: true\`, then END YOUR TURN. The completion notification re-invokes you. Do not read the output file, \`tail\`/\`wc\`/\`pgrep\` it, or start a second watcher on a log another run already owns \u2014 a quiet gate is still running.`,
     `- Never wrap a gate in a foreground \`timeout\`: killing your own run at 590s produces exit 124/143 and ZERO information, and you then have to run it again unbounded. \`sleep N; <cmd>\` is hard-blocked for the same reason.`,
     `- Never relaunch a command you just killed without changing something. State cwd explicitly in the command (\`cd /workspaces/repo && \u2026\`, \`--root\`, \`git -C\`) rather than trusting the shell's working directory.`,
-    `- The completion notification reports the WRAPPER's exit code, not the gate's. A notification saying "exit code 0" over a log containing \`EXIT:1\` is a failed gate. The \`EXIT:\` line in the log is the authority.`,
+    `- The completion notification reports the WRAPPER's exit code. With the propagating idiom above, \`(exit $ec)\` makes that the gate's own code; a wrapper that ends on a bare \`echo\` reports 0 no matter what failed. Whenever the notification and the log disagree, the \`EXIT:\` line in the log is the authority.`,
     `- Scope heavy gates to what you changed (\`--filter=<pkg>\`). An unscoped \`check:affected\` can pull a large web typecheck into scope for a diff touching no web files and get OOM-killed (exit 137) after minutes, where the scoped run takes seconds.`,
     `- Merge the base BEFORE the gate pass, never after (see the Pre-PR Protocol). If that merge touched \`package.json\`/\`bun.lock\`, run \`bun install\` before starting the gate \u2014 a changed lockfile makes gates fail for reasons unrelated to your diff.`
   ];
@@ -9162,6 +9224,10 @@ function buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode) {
   return parts;
 }
 
+// src/execution/system-prompt.ts
+import { readFileSync } from "fs";
+import { join as join11 } from "path";
+
 // src/execution/mode-prompt.ts
 var SP_DESC_MAX_CHARS = 80;
 function truncateDescription(desc, maxChars) {
@@ -9249,6 +9315,17 @@ function buildPlanDocumentationSection(context) {
     `- Identification auto-fills title, story points, and icon with quick AI guesses. After exploring, refine the title, story points, and risk with update_task_properties whenever they no longer match what the work actually is \u2014 adjust in either direction. Icons are automatic \u2014 never set them.`
   ];
 }
+function buildPlanRevisionSection() {
+  return [
+    ``,
+    `### The plan can change while you sleep`,
+    `If a turn opens with "The plan changed since this build was dispatched", honor it BEFORE your next Write or Edit:`,
+    `1. Call get_current_plan and read the current plan in full.`,
+    `2. Compare it against the plan you were launched with \u2014 the current plan wins.`,
+    `3. Drop or redo whatever the revision supersedes, and say so with post_to_chat if it invalidates work you already committed.`,
+    `Building on a superseded plan is the most expensive mistake a resumed card can make.`
+  ];
+}
 function buildNoPrWhenNoCodeSection(baseBranch) {
   const diffCommand = baseDiffCommand(baseBranch);
   return [
@@ -9448,6 +9525,7 @@ function buildAutoPrompt(context, runnerMode) {
       ...buildPrGuideSection(),
       ...buildNoPrWhenNoCodeSection(context?.baseBranch)
     ],
+    ...buildPlanRevisionSection(),
     ``,
     `### Autonomous Guidelines:`,
     `- Make decisions independently \u2014 do not ask the team for approval at each step`,
@@ -9477,7 +9555,8 @@ function buildBuildingPrompt(context) {
       ...buildPrGuideSection(),
       ...buildNoPrWhenNoCodeSection(context?.baseBranch),
       ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
-    ]
+    ],
+    ...buildPlanRevisionSection()
   ];
   if (context) parts.push(...buildPropertyInstructions(context));
   return parts.join("\n");
@@ -9633,6 +9712,14 @@ function buildReviewPrompt(context) {
 }
 
 // src/execution/system-prompt.ts
+function repoHasScript(workspaceDir, script) {
+  try {
+    const pkg = JSON.parse(readFileSync(join11(workspaceDir, "package.json"), "utf8"));
+    return typeof pkg.scripts?.[script] === "string";
+  } catch {
+    return false;
+  }
+}
 function formatProjectAgentLine(agent) {
   const role = agent.role ? `role: ${agent.role}` : "role: unassigned";
   const sp = agent.storyPoints === null || agent.storyPoints === void 0 ? "" : `, story points: ${agent.storyPoints}`;
@@ -9700,27 +9787,34 @@ Workflow:`,
     `- If you toggled into active mode temporarily, mention when you're done so the team can switch you back to planning mode.`
   ].filter(Boolean);
 }
-function buildTaskAgentPreamble(context) {
+function buildTaskAgentPreamble(context, workspaceDir) {
+  const managedStack = repoHasScript(workspaceDir, "web:rebuild");
+  const stackLines = managedStack ? [
+    `- The web app is served on port 3050, the API on port 7090.`,
+    `- Web is served from a production build, not \`next dev\` \u2014 your edits do NOT hot-reload. Run \`bun run web:rebuild\` (rebuild + restart lands in ~2s) before re-testing a UI change. The API hot-reloads on its own.`
+  ] : [
+    `- Ports, running services, and rebuild commands differ per repo, so this brief asserts none of them. Whether an app is already running depends on the Start command this project configured. Read this repo's CLAUDE.md and its rules files for those facts, check what is actually listening before you use a port, and start or rebuild the app with the repo's own scripts.`
+  ];
   return [
     `You are an AI agent working on a task for the "${context.title}" project.`,
     `You are running inside a Claudespace pod (a Kubernetes container, NOT a GitHub Codespace) with full access to the repository.`,
     `
-Environment \u2014 already built and running. These are the facts you would otherwise spend calls discovering:`,
-    `- The repo is cloned at your working directory with \`${context.githubBranch}\` checked out, dependencies installed, database migrated, git configured, and the dev stack up. Commit and push directly to this branch.`,
-    `- The web app is served on port 3050, the API on port 7090.`,
-    `- Web is served from a production build, not \`next dev\` \u2014 your edits do NOT hot-reload. Run \`bun run web:rebuild\` (rebuild + restart lands in ~2s) before re-testing a UI change. The API hot-reloads on its own.`,
+Environment \u2014 already built${managedStack ? " and running" : ""}. These are the facts you would otherwise spend calls discovering:`,
+    `- The repo is cloned at your working directory with \`${context.githubBranch}\` checked out, dependencies installed, database migrated, git configured${managedStack ? ", and the dev stack up" : ""}. Commit and push directly to this branch.`,
+    ...stackLines,
     `- Browser automation is the Playwright CLI (\`playwright\`, pinned 1.62.1), NOT an MCP server \u2014 there are no \`mcp__playwright__*\` tools here. Only the headless shell is baked, so a launch must name it AND disable the sandbox: \`chromium.launch({ channel: "chromium-headless-shell", args: ["--no-sandbox"] })\`. A bare \`chromium.launch()\` FAILS: since playwright 1.49 that resolves to the full browser, which is deliberately not installed (pods have no display and cannot run Chromium's sandbox). Screenshots land wherever you write them \u2014 move or delete them before committing.`,
     `- The clone is \`--single-branch\`, so a bare \`git fetch origin <branch>\` does NOT create \`origin/<branch>\`. To reference any other branch, use the explicit refspec: \`git fetch origin <branch>:refs/remotes/origin/<branch>\`.`,
     `- The shell cwd resets between Bash calls, and so does every shell variable. A var you export in one call is EMPTY in the next, which silently redirects output to \`/\` and loses it. Write literal absolute paths (\`git -C\`, \`bun run --cwd\`), and \`mkdir -p\` a directory in the SAME call as the redirect that writes to it.`,
     `- The \`gh\` CLI is available for READ-ONLY PR and CI state (\`gh pr view\`, \`gh pr checks\`, \`gh pr diff\`). Use the mcp__conveyor__* tools for anything that mutates a PR or card.`,
     `- The core mcp__conveyor__* tools are preloaded \u2014 call them directly; do NOT spend a ToolSearch call on them. For any tool that IS still deferred (schema not loaded), load ALL the schemas you expect to need in ONE ToolSearch call using fully-qualified names (query "select:Monitor,mcp__conveyor__<name>" \u2014 bare MCP tool names without the mcp__<server>__ prefix do not match); never guess a deferred tool's parameters.`,
-    `Because the environment is already up, do not run installs, builds, database setup, dev-server starts, or exploratory \`pwd\`/\`ls\` probes to confirm any of the above. Run them only when a specific error demands it.`,
+    managedStack ? `Because the environment is already up, do not run installs, builds, database setup, dev-server starts, or exploratory \`pwd\`/\`ls\` probes to confirm any of the above. Run them only when a specific error demands it.` : `Do not run installs, database setup, or exploratory \`pwd\`/\`ls\` probes to confirm any of the above \u2014 they are done. If the task needs a running app, check whether one is already up before you start it, and use the repo's own scripts.`,
     `
 Working rules:`,
     `- Read a file before your first Write/Edit to it, and batch multiple changes to the same file into a single call instead of many sequential edits.`,
     `- To learn what calls a symbol or where it lives, query the prebuilt code graph before grepping: \`graphify query "<SymbolName>"\` from the repo root. Query a SYMBOL, never a sentence \u2014 \`graphify query "resolveTaskBaseBranch"\` returns the definition plus every call site, while "how does a task get its base branch" seeds unrelated start nodes and returns test files and loggers. Don't know the symbol yet? Grep for the name first, then query it: grep finds names, the graph finds relationships. \`No matching nodes found\` means "not in this graph" (it is prebuilt, so very recent code is absent), NOT "not in the codebase" \u2014 fall back to \`git grep\`. Skip all of this if \`graphify-out/graph.json\` is not present.`,
     `- When a build/lint/test run fails, capture its output to a file once and grep the file \u2014 never re-run the suite just to re-filter the same output.`,
     `- Waiting on long-running commands: if a gate finishes in under ~2 minutes, run it in the foreground with a timeout. For a longer one, launch it with run_in_background and STOP; a completion notification arrives when it finishes, and the workspace stays awake for as long as background work is outstanding, so a backgrounded gate will not be killed by an idle sleep. For the final pre-PR gate a bounded foreground run (\`timeout 590 <gate>\` with Bash \`timeout: 600000\`) is still preferred as defense in depth \u2014 it survives a pod resume, which a background job does not. Never busy-wait with sleep/pgrep/tail loops, and never re-run the suite to escape a wait that looks stalled.`,
+    `- Ending your turn with NO tool call is the correct way to wait, and it is safe: the pod stays alive and the next notification re-invokes you. Never emit filler commands (\`echo waiting\`, \`true\`, \`sleep N; echo done\`) to "stay alive" \u2014 they are detected and blocked. The proven long-wait shape: start the job with run_in_background, then end the turn. Arm a ScheduleWakeup (delaySeconds 900-1500, prompt restating your next steps) only when nothing will notify you \u2014 an external CI run, a deploy, a remote queue \u2014 never as insurance against a background job's own notification, which does fire.`,
     `
 Git:`,
     `- Stay on \`${context.githubBranch}\` for the whole task: do not check out another branch and do not create one. It was cut from \`${context.baseBranch}\`, and PRs target that automatically.`,
@@ -9734,7 +9828,7 @@ function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
   if (isPackRunner) {
     return buildPackRunnerSystemPrompt(context, config, setupLog);
   }
-  const parts = isPmActive ? buildActivePreamble(context, config.workspaceDir) : isPm ? buildPmPreamble(context) : buildTaskAgentPreamble(context);
+  const parts = isPmActive ? buildActivePreamble(context, config.workspaceDir) : isPm ? buildPmPreamble(context) : buildTaskAgentPreamble(context, config.workspaceDir);
   if (setupLog.length > 0) {
     parts.push(
       `
@@ -9908,6 +10002,7 @@ ${context.description}`);
 ## Plan
 ${truncatePlanForPrompt(context.plan)}`);
   }
+  parts.push(...buildPlanRevisionNotice(context));
   if (context.files && context.files.length > 0) {
     parts.push(`
 ## Attached Files`);
@@ -10178,7 +10273,9 @@ async function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pack" || mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
     const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
-    if (sessionRelaunch) return sessionRelaunch;
+    if (sessionRelaunch) {
+      return [...buildPlanRevisionNotice(context), sessionRelaunch].join("\n");
+    }
   }
   const isPm = mode === "pm";
   let scenario = detectRelaunchScenario(context, isPm);
@@ -10926,7 +11023,7 @@ var getAttachmentContract = defineToolContract({
 });
 var attachmentTags = f.optional(
   f.array(f.string(), {
-    desc: `Glossary tag names this file is a relevant example of, e.g. a screenshot of the tag page tagged "tag". Use it when the file shows a tagged entity in a particular state: the tag's page lists its recent tagged attachments, so a reader can see what the entity looks like across the app and spot visual changes over time. Names are matched case-insensitively within the project; a name that matches no tag is reported back and never fails the upload. Max 5.`
+    desc: `Glossary tag names this file is a relevant example of. MUST be a JSON array of quoted strings, e.g. ["ops-hub", "platform-support"] \u2014 bare unquoted words are invalid JSON and fail the whole call before it is parsed (21 fleet calls in one week died this way). Use it when the file shows a tagged entity in a particular state: the tag's page lists its recent tagged attachments, so a reader can see what the entity looks like across the app and spot visual changes over time. Names are matched case-insensitively within the project; a name that matches no tag is reported back and never fails the upload. Max 5.`
   })
 );
 var uploadAttachmentContract = defineToolContract({
@@ -11129,7 +11226,12 @@ function buildGetCurrentPlanTool(connection) {
         const ctx = await connection.call("getTaskContext", {
           sessionId: connection.sessionId
         });
-        return textResult(ctx.plan ?? "No plan available.");
+        const plan = ctx.plan ?? "No plan available.";
+        return textResult(
+          ctx.planRevisedAt ? `\u26A0\uFE0F This plan was revised ${ctx.planRevisedAt}, after your build was dispatched. Treat it as the truth and drop any work it supersedes.
+
+${plan}` : plan
+        );
       } catch {
         return textResult("Could not fetch updated plan.");
       }
@@ -11478,6 +11580,35 @@ function buildForceUpdateTaskStatusTool(connection) {
     }
   );
 }
+async function ensureHeadPushed(connection, cwd, headBranch, skipVerify) {
+  if (!await hasUnpushedCommits(cwd)) return null;
+  const pushSuccess = await pushToOrigin(
+    cwd,
+    async () => {
+      try {
+        const result = await connection.call("refreshGithubToken", {
+          sessionId: connection.sessionId
+        });
+        return result.token;
+      } catch {
+        return void 0;
+      }
+    },
+    skipVerify
+  );
+  if (pushSuccess) {
+    connection.sendEvent({ type: "message", content: "Auto-pushed committed changes to origin" });
+    return null;
+  }
+  if (await remoteMatchesLocalHead(cwd, headBranch)) {
+    connection.sendEvent({
+      type: "message",
+      content: "Push reported an error but origin already has this HEAD \u2014 continuing"
+    });
+    return null;
+  }
+  return `Failed to push changes to origin, and origin does not have this HEAD. Verify before treating this as fatal: \`git ls-remote origin ${headBranch}\` \u2014 if the tip equals your HEAD the push actually landed and you can retry this tool. Otherwise refresh the credential (refresh_github_token) or push manually, then retry.`;
+}
 function buildCreatePullRequestTool(connection, config) {
   return defineContractTool(
     createPullRequestContract,
@@ -11506,32 +11637,8 @@ Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>`;
             );
           }
         }
-        if (await hasUnpushedCommits(cwd)) {
-          const pushSuccess = await pushToOrigin(
-            cwd,
-            async () => {
-              try {
-                const result2 = await connection.call("refreshGithubToken", {
-                  sessionId: connection.sessionId
-                });
-                return result2.token;
-              } catch {
-                return void 0;
-              }
-            },
-            skipVerify ?? true
-          );
-          if (pushSuccess) {
-            connection.sendEvent({
-              type: "message",
-              content: "Auto-pushed committed changes to origin"
-            });
-          } else {
-            return textResult(
-              "Failed to push changes to origin. Please check git status and push manually before creating PR."
-            );
-          }
-        }
+        const pushError = await ensureHeadPushed(connection, cwd, headBranch, skipVerify ?? true);
+        if (pushError) return textResult(pushError);
         const result = await connection.call("createPullRequest", {
           sessionId: connection.sessionId,
           title,
@@ -11556,10 +11663,10 @@ ${result.glossaryNote}` : "";
           `Failed to create pull request: ${msg}
 
 Troubleshooting:
+- FIRST verify the failure is real: \`gh pr list --head <branch>\` \u2014 if a PR exists, it opened and this error is stale; do not re-create, bundle, or post a blocked escalation
 - Ensure all changes are committed and pushed to the remote branch
 - Check that the branch exists on the remote (run: git push -u origin HEAD)
-- Verify there isn't already an open PR for this branch
-- If git auth fails, the token may have expired \u2014 retry the operation`
+- If git auth fails, the token may have expired \u2014 refresh_github_token once, then retry`
         );
       }
     }
@@ -11785,7 +11892,7 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { basename, extname, isAbsolute, join as join11 } from "path";
+import { basename, extname, isAbsolute, join as join12 } from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -11838,7 +11945,7 @@ ${snippet}`;
 function buildUploadAttachmentTool(connection, config) {
   return defineContractTool(uploadAttachmentContract, async ({ path: path2, title, tags }) => {
     try {
-      const filePath = isAbsolute(path2) ? path2 : join11(config.workspaceDir, path2);
+      const filePath = isAbsolute(path2) ? path2 : join12(config.workspaceDir, path2);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -12378,7 +12485,7 @@ import { z as z16 } from "zod";
 
 // src/execution/context-path-verifier.ts
 import { readFile as readFile2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join12, normalize } from "path";
+import { isAbsolute as isAbsolute2, join as join13, normalize } from "path";
 var PROBLEM_TEXT = {
   not_found: "does not exist in the repo",
   expected_folder: "is a file, not a folder \u2014 use type 'file', 'rule', or 'doc'",
@@ -12423,7 +12530,7 @@ async function verifyContextPaths(links, workspaceDir) {
       problems.push({ type: link.type, path: link.path, reason: shape });
       continue;
     }
-    const absolutePath = join12(workspaceDir, toRelativePath(link.path));
+    const absolutePath = join13(workspaceDir, toRelativePath(link.path));
     const stat = await statWorkspacePath(absolutePath);
     const wantsDirectory = expectsDirectory(link.type);
     if (!stat.exists) {
@@ -12983,17 +13090,26 @@ var ReviewGuideToolSchema = z18.strictObject({
     "REQUIRED top-level array (never text appended to overview) of ordered conceptual sections."
   )
 });
-var FLATTENED_SECTIONS_PATTERN = /<\/overview>\s*<parameter name="sections">/;
+var FLATTENED_SECTIONS_PATTERN = /<\/overview>\s*(?:<parameter name="sections">|<sections>)/;
+var TRAILING_TAGS_PATTERN = /(?:\s*<\/(?:parameter|sections|invoke)>)+\s*$/;
+function sliceOutermostArray(tail) {
+  const start = tail.indexOf("[");
+  const end = tail.lastIndexOf("]");
+  return start >= 0 && end > start ? tail.slice(start, end + 1) : null;
+}
 function recoverFlattenedGuide(overview) {
   const match = FLATTENED_SECTIONS_PATTERN.exec(overview);
   if (!match) return null;
-  const head = overview.slice(0, match.index);
-  const tail = overview.slice(match.index + match[0].length).replace(/<\/parameter>\s*$/, "").trim();
-  try {
-    return { overview: head.trim(), sections: JSON.parse(tail) };
-  } catch {
-    return null;
+  const head = overview.slice(0, match.index).trim();
+  const tail = overview.slice(match.index + match[0].length).replace(TRAILING_TAGS_PATTERN, "").trim();
+  for (const candidate of [tail, sliceOutermostArray(tail)]) {
+    if (!candidate) continue;
+    try {
+      return { overview: head, sections: JSON.parse(candidate) };
+    } catch {
+    }
   }
+  return null;
 }
 async function resolveGitHeadSha(cwd) {
   try {
@@ -13020,7 +13136,7 @@ function buildPublishReviewGuideTool(connection, options = {}) {
         const recovered = recoverFlattenedGuide(overview);
         if (!recovered) {
           throw new Error(
-            "publish_review_guide requires a top-level `sections` array \u2014 an ordered list of conceptual sections, each with title, explanation, and files[]. Do not append the sections to `overview` as text. Retry with sections as a real array argument."
+            "publish_review_guide requires a top-level `sections` array \u2014 an ordered list of conceptual sections, each with title, explanation, and files[]. Your call arrived with only `reviewedSha` and `overview`; the `sections` parameter never reached the server, which usually means the call encoding flattened it into `overview`. Do not append the sections to `overview` as text. Retry with sections as a real array argument, and shorten `overview` if the failure repeats."
           );
         }
         resolvedOverview = recovered.overview;
@@ -13746,7 +13862,7 @@ function collectMissingProps(taskProps) {
 }
 
 // src/runner/heavy-gate.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import path from "path";
 var GATE_KEYS = ["heavy", "test", "typecheck", "build"];
 function runDir() {
@@ -13763,7 +13879,7 @@ function pidAlive(pid) {
 function isHeavyGateActive() {
   for (const key of GATE_KEYS) {
     try {
-      const raw = readFileSync(path.join(runDir(), `${key}.pid`), "utf8").trim();
+      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 {
@@ -13776,6 +13892,18 @@ function isHeavyGateActive() {
 var REPEAT_INTERRUPT_THRESHOLD = 4;
 var REPEAT_INTERRUPT_INTERVAL = 4;
 var REPEAT_FORCE_STOP_THRESHOLD = 12;
+var NOOP_ALLOWANCE = 2;
+var NOOP_FORCE_STOP_THRESHOLD = 30;
+var NOOP_FINGERPRINT = "Bash:NOOP_KEEPALIVE";
+function isNoOpKeepAlive(command) {
+  const cmd = command.trim().replace(/\s+/g, " ");
+  if (/^(true|:)$/.test(cmd)) return true;
+  const constantEcho = String.raw`echo( -[neE]+)?( ["']?[A-Za-z0-9 ._,:-]{0,60}["']?)?`;
+  if (new RegExp(`^${constantEcho}$`).test(cmd)) return true;
+  if (new RegExp(`^sleep \\d+ ?(?:(?:;|&&) ?${constantEcho})?$`).test(cmd)) return true;
+  if (/^date( \+\S+)?$/.test(cmd)) return true;
+  return false;
+}
 var UNCOUNTED_TOOLS = /* @__PURE__ */ new Set(["ExitPlanMode", "AskUserQuestion"]);
 function stableStringify(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
@@ -13787,7 +13915,9 @@ function fingerprintToolCall(toolName, input) {
   if (!toolName || UNCOUNTED_TOOLS.has(toolName)) return null;
   if (toolName === "Bash") {
     const command = String(input.command ?? "").trim().replace(/\s+/g, " ");
-    return command ? `Bash:${command}` : null;
+    if (!command) return null;
+    if (isNoOpKeepAlive(command)) return NOOP_FINGERPRINT;
+    return `Bash:${command}`;
   }
   return `${toolName}:${stableStringify(input)}`;
 }
@@ -13796,10 +13926,16 @@ var ToolLoopTracker = class {
   streak = 0;
   /** True once this streak has been reported to chat — one message per streak. */
   reported = false;
+  /** Session-cumulative no-op keep-alive count (never reset by other calls). */
+  noOps = 0;
   /** Repeats of the current fingerprint, including the call being recorded. */
   get repeatCount() {
     return this.streak;
   }
+  /** Total no-op keep-alive calls recorded this session. */
+  get noOpCount() {
+    return this.noOps;
+  }
   /** True when the current streak has already been posted to chat. */
   get alreadyReported() {
     return this.reported;
@@ -13810,6 +13946,14 @@ var ToolLoopTracker = class {
   }
   /** Record one call and decide what to do about it. */
   record(fingerprint) {
+    if (fingerprint === NOOP_FINGERPRINT) {
+      this.noOps++;
+      this.fingerprint = fingerprint;
+      this.streak = 1;
+      if (this.noOps >= NOOP_FORCE_STOP_THRESHOLD) return "force_stop";
+      if (this.noOps > NOOP_ALLOWANCE) return "interrupt";
+      return "ok";
+    }
     if (fingerprint !== this.fingerprint) {
       this.fingerprint = fingerprint;
       this.streak = 1;
@@ -13829,6 +13973,9 @@ function buildRepeatLoopMessage(repeatCount, heavyGateActive) {
   const advice = heavyGateActive ? `A build gate (test/typecheck/build) is running on this pod right now. Do NOT poll its log. End your turn \u2014 the completion notification re-invokes you when the gate finishes.` : `If you are waiting on a background job, end your turn instead of polling; the completion notification re-invokes you. If you are stuck, change your approach: read a different file, run a different command, or post to chat and ask the team.`;
   return `${head} ${advice} Call a different tool now.`;
 }
+function buildNoOpKeepAliveMessage(noOpCount) {
+  return `Conveyor blocked this call: it is a no-op keep-alive (${noOpCount} this session). You do not need to emit tool calls to stay alive. Ending your turn with NO tool call is safe and expected while waiting: the pod stays up and the completion notification re-invokes you. If nothing is running, do real work or end the turn. For a long wait with no notification source, use Monitor or ScheduleWakeup instead of filler commands.`;
+}
 function buildRepeatLoopChatMessage(repeatCount, forceStopped) {
   if (forceStopped) {
     return `Agent force-stopped after repeating the same tool call ${repeatCount} times in a row. It appears stuck \u2014 send a message to resume.`;
@@ -14078,6 +14225,20 @@ function checkToolLoop(host, toolName, input) {
   const tracker = host.toolLoop ??= new ToolLoopTracker();
   const verdict = tracker.record(fingerprint);
   if (verdict === "ok") return null;
+  if (fingerprint === NOOP_FINGERPRINT) {
+    const noOps = tracker.noOpCount;
+    if (verdict === "force_stop") {
+      host.connection.postChatMessage(
+        `Agent force-stopped after ${noOps} no-op keep-alive commands. It appears to be spinning instead of waiting \u2014 send a message to resume.`
+      );
+      host.requestStop();
+      return {
+        behavior: "deny",
+        message: `Stopped after ${noOps} no-op keep-alive calls this session.`
+      };
+    }
+    return { behavior: "deny", message: buildNoOpKeepAliveMessage(noOps) };
+  }
   const repeats = tracker.repeatCount;
   if (verdict === "force_stop") {
     host.connection.postChatMessage(buildRepeatLoopChatMessage(repeats, true));
@@ -14220,7 +14381,7 @@ function resolveSessionStart(lineageKey, cwd) {
 function repairTornSessionFile(path2) {
   try {
     if (!existsSync2(path2)) return false;
-    const content = readFileSync2(path2, "utf8");
+    const content = readFileSync3(path2, "utf8");
     if (content.length === 0) return false;
     let keepEnd = content.length;
     if (!content.endsWith("\n")) {
@@ -16803,6 +16964,9 @@ var SessionRunner = class _SessionRunner {
       title: ctx.title,
       description: ctx.description,
       plan: ctx.plan,
+      // The server hands this to exactly one context fetch per revision, so it
+      // must survive the mapping or the notice is lost.
+      planRevisedAt: ctx.planRevisedAt ?? null,
       status: ctx.status,
       chatHistory,
       agentId: ctx.agentId ?? null,
@@ -16975,7 +17139,10 @@ ${outcome.failures.join("\n")}
     try {
       const ctx = await this.connection.call("getTaskContext", {
         sessionId: this.sessionId,
-        includeHistory: false
+        includeHistory: false,
+        // Bookkeeping fetch — it must not swallow a plan-revised notice the
+        // next prompt is about to carry.
+        peekPlanRevision: true
       });
       if (ctx?.githubBranch && this.fullContext) {
         this.fullContext.githubBranch = ctx.githubBranch;
@@ -17084,12 +17251,12 @@ ${outcome.failures.join("\n")}
 };
 
 // src/setup/config.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readWorkspaceFile(join13(workspaceDir, DEVCONTAINER_PATH));
+    const raw = await readWorkspaceFile(join14(workspaceDir, DEVCONTAINER_PATH));
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)

package/dist/cli.js

@@ -35,7 +35,7 @@ import {
   sampleKeyUsage,
   statWorkspacePath,
   workspacePathExists
-} from "./chunk-2KZV6I5Z.js";
+} from "./chunk-7MMECTTJ.js";
 import {
   reportBootMilestone
 } from "./chunk-QU53HND5.js";
@@ -1715,7 +1715,7 @@ function hostsSpawnedChildren(mode) {
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-7UWVK777.js");
+  const { runBoot } = await import("./boot-PKHZUDAC.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -2100,7 +2100,10 @@ void checkSessionTaskIdentity({
   sessionId: process.env.CONVEYOR_SESSION_ID,
   taskId: CONVEYOR_TASK_ID,
   fetchSessionTaskId: async (sessionId) => {
-    const ctx = await runner.connection.call("getTaskContext", { sessionId });
+    const ctx = await runner.connection.call("getTaskContext", {
+      sessionId,
+      peekPlanRevision: true
+    });
     return ctx.id;
   },
   logger: logger5

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   unshallowRepo,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-2KZV6I5Z.js";
+} from "./chunk-7MMECTTJ.js";
 import "./chunk-QU53HND5.js";
 import "./chunk-IA45XHOA.js";
 import {

package/package.json

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