@rallycry/conveyor-agent 10.13.69 → 10.13.70

package/dist/{chunk-2KZV6I5Z.js → chunk-E6WWH4WJ.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);
@@ -8343,7 +8355,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) {
@@ -8612,7 +8624,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 +8637,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 +9174,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) {
@@ -9633,6 +9649,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 +9724,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 +9765,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(
       `
@@ -10926,7 +10957,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({
@@ -11478,6 +11509,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 +11566,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 +11592,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 +11821,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 +11874,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 +12414,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 +12459,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 +13019,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 +13065,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 +13791,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 +13808,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 +13821,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 +13844,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 +13855,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 +13875,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 +13902,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 +14154,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 +14310,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")) {
@@ -17084,12 +17174,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-E6WWH4WJ.js";
 import {
   reportBootMilestone
 } from "./chunk-QU53HND5.js";

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   unshallowRepo,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-2KZV6I5Z.js";
+} from "./chunk-E6WWH4WJ.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.70",
   "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",