@rallycry/conveyor-agent 11.0.1 → 11.0.3

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

@@ -13150,7 +13150,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 {
@@ -13417,7 +13419,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";
 }
@@ -14632,7 +14634,6 @@ 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 SessionRunner = class _SessionRunner {
   connection;
@@ -15113,26 +15114,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.
    *
-   * 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.
+   * 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.
+   *
+   * 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",
@@ -15730,6 +15753,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 +15778,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,

package/dist/cli.js

@@ -27,7 +27,7 @@ import {
   resolveTuiKindFromEnv,
   runUsageProbe,
   sampleKeyUsage
-} from "./chunk-QETNCXIR.js";
+} from "./chunk-DHKAY7HQ.js";
 import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,

package/dist/index.d.ts

@@ -802,18 +802,41 @@ declare class SessionRunner {
     /** Returns true if an initial query was executed, false otherwise. */
     private executeInitialMode;
     /**
-     * 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.
      *
-     * 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.
+     * 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.
+     *
+     * 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.
      */
     private requeueWedgedInitialQuery;
     /**
@@ -957,6 +980,8 @@ declare class SessionRunner {
     private _finalState;
     /** The final status after run() completes. Use to determine exit code. */
     get finalState(): AgentRunnerStatus | null;
+    /** Does a transcript already exist for this session's lineage? */
+    private resolvesToTranscriptResume;
     private buildTaskContextSnapshot;
     private buildInitializationContext;
     private logInitialization;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-QETNCXIR.js";
+} from "./chunk-DHKAY7HQ.js";
 import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.1",
+  "version": "11.0.3",
   "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",

package/skills/conveyor-local-loop/SKILL.md

@@ -173,7 +173,10 @@ notification is the wake. The `ScheduleWakeup` you still arm is the fallback for
 the case where the wait dies silently — use the pacing table's background-gate
 row (1200–1800s), not a second, shorter timer.
 
-- Prefer `node_modules/.bin/conveyor-wait`. If it is absent, use
+- Prefer `node_modules/.bin/conveyor-wait`. Gate on
+  `[ -x node_modules/.bin/conveyor-wait ]`, not on the path existing: in a
+  checkout that has not been built the bin is a symlink into an unbuilt
+  `dist/`, so it looks present and fails to run. When that test is false, use
   `npx -y -p @rallycry/conveyor-mcp@latest conveyor-wait`. The `-p` form
   matters: inside the conveyor monorepo a bare
   `npx @rallycry/conveyor-mcp` misresolves.