@rallycry/conveyor-agent 10.13.18 → 10.13.50

package/dist/{client-BU4XA7CV.js → client-LRVVHTNG.js}

@@ -4,7 +4,7 @@ import {
   WorkbenchError,
   getWorkbenchClient,
   resetWorkbenchClient
-} from "./chunk-UDSRAHKP.js";
+} from "./chunk-QOJTJCYZ.js";
 import "./chunk-4VUQ2NPF.js";
 import "./chunk-JIGG755T.js";
 export {
@@ -14,4 +14,4 @@ export {
   getWorkbenchClient,
   resetWorkbenchClient
 };
-//# sourceMappingURL=client-BU4XA7CV.js.map
+//# sourceMappingURL=client-LRVVHTNG.js.map

package/dist/heartbeat-worker.js

@@ -1,7 +1,9 @@
 import {
+  buildConveyorSocketOptions,
+  heartbeatStatusFor,
   lagFromBuffer,
   statusFromBuffer
-} from "./chunk-7TQO4ZF4.js";
+} from "./chunk-5OQQSDVT.js";
 
 // src/connection/heartbeat-worker.ts
 import { parentPort, workerData } from "worker_threads";
@@ -9,16 +11,10 @@ import { io } from "socket.io-client";
 var data = workerData;
 var view = new Float64Array(data.sharedBuffer);
 var taskToken = data.taskToken;
-var socket = io(data.apiUrl, {
-  auth: (cb) => cb({ taskToken, runnerMode: data.runnerMode }),
-  transports: ["websocket"],
-  reconnection: true,
-  reconnectionAttempts: Infinity,
-  reconnectionDelay: 2e3,
-  reconnectionDelayMax: 3e4,
-  randomizationFactor: 0.3,
-  extraHeaders: { "ngrok-skip-browser-warning": "true" }
-});
+var socket = io(
+  data.apiUrl,
+  buildConveyorSocketOptions((cb) => cb({ taskToken, runnerMode: data.runnerMode }))
+);
 parentPort?.on("message", (msg) => {
   if (msg?.taskToken) taskToken = msg.taskToken;
 });
@@ -34,7 +30,9 @@ function beat() {
     {
       sessionId: data.sessionId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      status: statusFromBuffer(view),
+      // `waiting` (runner idle, background work still running in the pod)
+      // goes out as `active` — see heartbeatStatusFor.
+      status: heartbeatStatusFor(statusFromBuffer(view)),
       loopLagMs: Math.round(lagFromBuffer(view))
     },
     // Ack intentionally ignored: a missed beat self-heals on the next tick,

package/dist/heartbeat-worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/connection/heartbeat-worker.ts"],"sourcesContent":["/**\n * Starvation-proof heartbeat: a worker thread with its OWN event loop and its\n * OWN Socket.IO connection, so a stalled/starved main loop cannot silence the\n * session's liveness signal.\n *\n * Why this exists: the v3 lease chain (heartbeat → renewSessionLease, TTL\n * 150s + 120s stranded grace) reaps a session whose agent goes quiet for\n * ~4.5 minutes. A main-loop stall during a heavy gate used to do exactly\n * that — the session was declared stranded and the restart tore down the\n * in-flight run. This worker keeps beating through such stalls, reporting\n * `loopLagMs` (staleness of the main loop's shared tick) so the API can tell\n * \"alive but busy\" (renew the lease) from \"wedged\" (stop renewing past the\n * wedge ceiling and let the normal recovery run). The main loop still sends\n * its richer heartbeat when healthy — duplicate renewals are idempotent.\n *\n * Deliberately minimal: no bootstrap token refresh (the main thread posts\n * rotated tokens via postMessage), no reconnect ceremony beyond Socket.IO's\n * built-in retry, and it never throws — a broken worker just means heartbeats\n * degrade to main-loop-only, which is yesterday's behavior.\n */\nimport { parentPort, workerData } from \"node:worker_threads\";\nimport { io } from \"socket.io-client\";\nimport { lagFromBuffer, statusFromBuffer } from \"./loop-lag.js\";\n\ninterface HeartbeatWorkerData {\n  apiUrl: string;\n  taskToken: string;\n  sessionId: string;\n  runnerMode: string;\n  sharedBuffer: SharedArrayBuffer;\n  intervalMs: number;\n}\n\nconst data = workerData as HeartbeatWorkerData;\nconst view = new Float64Array(data.sharedBuffer);\nlet taskToken = data.taskToken;\n\nconst socket = io(data.apiUrl, {\n  auth: (cb) => cb({ taskToken, runnerMode: data.runnerMode }),\n  transports: [\"websocket\"],\n  reconnection: true,\n  reconnectionAttempts: Infinity,\n  reconnectionDelay: 2000,\n  reconnectionDelayMax: 30000,\n  randomizationFactor: 0.3,\n  extraHeaders: { \"ngrok-skip-browser-warning\": \"true\" },\n});\n\n// The main thread posts rotated task tokens (bootstrap refresh) so the worker\n// socket survives token expiry. The next (re)connect picks it up via the auth\n// callback above; a server-initiated disconnect needs a manual nudge.\nparentPort?.on(\"message\", (msg: { taskToken?: string }) => {\n  if (msg?.taskToken) taskToken = msg.taskToken;\n});\n\nsocket.on(\"disconnect\", (reason: string) => {\n  if (reason === \"io server disconnect\" || reason === \"server namespace disconnect\") {\n    socket.connect();\n  }\n});\n\nfunction beat(): void {\n  if (!socket.connected) return;\n  socket.emit(\n    \"agentSessionService:heartbeat\",\n    {\n      sessionId: data.sessionId,\n      timestamp: new Date().toISOString(),\n      status: statusFromBuffer(view),\n      loopLagMs: Math.round(lagFromBuffer(view)),\n    },\n    // Ack intentionally ignored: a missed beat self-heals on the next tick,\n    // and the worker must never accumulate state or throw.\n    () => {},\n  );\n}\n\nsetInterval(beat, data.intervalMs);\n"],"mappings":";;;;;;AAoBA,SAAS,YAAY,kBAAkB;AACvC,SAAS,UAAU;AAYnB,IAAM,OAAO;AACb,IAAM,OAAO,IAAI,aAAa,KAAK,YAAY;AAC/C,IAAI,YAAY,KAAK;AAErB,IAAM,SAAS,GAAG,KAAK,QAAQ;AAAA,EAC7B,MAAM,CAAC,OAAO,GAAG,EAAE,WAAW,YAAY,KAAK,WAAW,CAAC;AAAA,EAC3D,YAAY,CAAC,WAAW;AAAA,EACxB,cAAc;AAAA,EACd,sBAAsB;AAAA,EACtB,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,qBAAqB;AAAA,EACrB,cAAc,EAAE,8BAA8B,OAAO;AACvD,CAAC;AAKD,YAAY,GAAG,WAAW,CAAC,QAAgC;AACzD,MAAI,KAAK,UAAW,aAAY,IAAI;AACtC,CAAC;AAED,OAAO,GAAG,cAAc,CAAC,WAAmB;AAC1C,MAAI,WAAW,0BAA0B,WAAW,+BAA+B;AACjF,WAAO,QAAQ;AAAA,EACjB;AACF,CAAC;AAED,SAAS,OAAa;AACpB,MAAI,CAAC,OAAO,UAAW;AACvB,SAAO;AAAA,IACL;AAAA,IACA;AAAA,MACE,WAAW,KAAK;AAAA,MAChB,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,MAClC,QAAQ,iBAAiB,IAAI;AAAA,MAC7B,WAAW,KAAK,MAAM,cAAc,IAAI,CAAC;AAAA,IAC3C;AAAA;AAAA;AAAA,IAGA,MAAM;AAAA,IAAC;AAAA,EACT;AACF;AAEA,YAAY,MAAM,KAAK,UAAU;","names":[]}
+{"version":3,"sources":["../src/connection/heartbeat-worker.ts"],"sourcesContent":["/**\n * Starvation-proof heartbeat: a worker thread with its OWN event loop and its\n * OWN Socket.IO connection, so a stalled/starved main loop cannot silence the\n * session's liveness signal.\n *\n * Why this exists: the v3 lease chain (heartbeat → renewSessionLease, TTL\n * 150s + 120s stranded grace) reaps a session whose agent goes quiet for\n * ~4.5 minutes. A main-loop stall during a heavy gate used to do exactly\n * that — the session was declared stranded and the restart tore down the\n * in-flight run. This worker keeps beating through such stalls, reporting\n * `loopLagMs` (staleness of the main loop's shared tick) so the API can tell\n * \"alive but busy\" (renew the lease) from \"wedged\" (stop renewing past the\n * wedge ceiling and let the normal recovery run). The main loop still sends\n * its richer heartbeat when healthy — duplicate renewals are idempotent.\n *\n * Deliberately minimal: no bootstrap token refresh (the main thread posts\n * rotated tokens via postMessage), no reconnect ceremony beyond Socket.IO's\n * built-in retry, and it never throws — a broken worker just means heartbeats\n * degrade to main-loop-only, which is yesterday's behavior.\n */\nimport { parentPort, workerData } from \"node:worker_threads\";\nimport { io } from \"socket.io-client\";\nimport { buildConveyorSocketOptions } from \"@project/shared/socket-core\";\nimport { heartbeatStatusFor, lagFromBuffer, statusFromBuffer } from \"./loop-lag.js\";\n\ninterface HeartbeatWorkerData {\n  apiUrl: string;\n  taskToken: string;\n  sessionId: string;\n  runnerMode: string;\n  sharedBuffer: SharedArrayBuffer;\n  intervalMs: number;\n}\n\nconst data = workerData as HeartbeatWorkerData;\nconst view = new Float64Array(data.sharedBuffer);\nlet taskToken = data.taskToken;\n\nconst socket = io(\n  data.apiUrl,\n  buildConveyorSocketOptions((cb) => cb({ taskToken, runnerMode: data.runnerMode })),\n);\n\n// The main thread posts rotated task tokens (bootstrap refresh) so the worker\n// socket survives token expiry. The next (re)connect picks it up via the auth\n// callback above; a server-initiated disconnect needs a manual nudge.\nparentPort?.on(\"message\", (msg: { taskToken?: string }) => {\n  if (msg?.taskToken) taskToken = msg.taskToken;\n});\n\nsocket.on(\"disconnect\", (reason: string) => {\n  if (reason === \"io server disconnect\" || reason === \"server namespace disconnect\") {\n    socket.connect();\n  }\n});\n\nfunction beat(): void {\n  if (!socket.connected) return;\n  socket.emit(\n    \"agentSessionService:heartbeat\",\n    {\n      sessionId: data.sessionId,\n      timestamp: new Date().toISOString(),\n      // `waiting` (runner idle, background work still running in the pod)\n      // goes out as `active` — see heartbeatStatusFor.\n      status: heartbeatStatusFor(statusFromBuffer(view)),\n      loopLagMs: Math.round(lagFromBuffer(view)),\n    },\n    // Ack intentionally ignored: a missed beat self-heals on the next tick,\n    // and the worker must never accumulate state or throw.\n    () => {},\n  );\n}\n\nsetInterval(beat, data.intervalMs);\n"],"mappings":";;;;;;;;AAoBA,SAAS,YAAY,kBAAkB;AACvC,SAAS,UAAU;AAanB,IAAM,OAAO;AACb,IAAM,OAAO,IAAI,aAAa,KAAK,YAAY;AAC/C,IAAI,YAAY,KAAK;AAErB,IAAM,SAAS;AAAA,EACb,KAAK;AAAA,EACL,2BAA2B,CAAC,OAAO,GAAG,EAAE,WAAW,YAAY,KAAK,WAAW,CAAC,CAAC;AACnF;AAKA,YAAY,GAAG,WAAW,CAAC,QAAgC;AACzD,MAAI,KAAK,UAAW,aAAY,IAAI;AACtC,CAAC;AAED,OAAO,GAAG,cAAc,CAAC,WAAmB;AAC1C,MAAI,WAAW,0BAA0B,WAAW,+BAA+B;AACjF,WAAO,QAAQ;AAAA,EACjB;AACF,CAAC;AAED,SAAS,OAAa;AACpB,MAAI,CAAC,OAAO,UAAW;AACvB,SAAO;AAAA,IACL;AAAA,IACA;AAAA,MACE,WAAW,KAAK;AAAA,MAChB,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA;AAAA;AAAA,MAGlC,QAAQ,mBAAmB,iBAAiB,IAAI,CAAC;AAAA,MACjD,WAAW,KAAK,MAAM,cAAc,IAAI,CAAC;AAAA,IAC3C;AAAA;AAAA;AAAA,IAGA,MAAM;AAAA,IAAC;AAAA,EACT;AACF;AAEA,YAAY,MAAM,KAAK,UAAU;","names":[]}

package/dist/index.d.ts

@@ -3,6 +3,11 @@ import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload,
 export * from '@project/shared';
 import { ChildProcess } from 'node:child_process';
 
+/** Append-only: the index into this array is what crosses the SharedArrayBuffer
+ *  to the heartbeat worker, so reordering would silently remap live statuses. */
+declare const LOOP_STATUS_VALUES: readonly ["active", "idle", "building", "waiting"];
+type LoopStatus = (typeof LOOP_STATUS_VALUES)[number];
+
 /**
  * The milestones an agent may declare — narrower than the server's full slug
  * set, which also covers server-generated review verdicts.
@@ -41,7 +46,7 @@ interface ApiKeyUpdateData {
  * Server push asking the builder pod to spawn a same-pod review child: a
  * second conveyor-agent process bound to a fresh review WorkspaceSession
  * (sessionId + sessionJwt). No taskId on the wire — the child inherits the
- * parent's CONVEYOR_TASK_ID and the server derives it from the JWT (SEC-9).
+ * parent's CONVEYOR_TASK_ID and the server derives it from the JWT.
  */
 interface SpawnReviewData {
     sessionId: string;
@@ -56,7 +61,7 @@ interface SpawnReviewData {
  * this pod: a second Claude TUI (mode "adhoc") or a raw login shell (mode
  * "shell"), each bound to a fresh WorkspaceSession (sessionId + sessionJwt).
  * No taskId on the wire — the child inherits the parent's CONVEYOR_TASK_ID
- * and the server derives it from the JWT (SEC-9).
+ * and the server derives it from the JWT.
  */
 interface SpawnTuiData {
     sessionId: string;
@@ -124,6 +129,12 @@ declare class AgentConnection {
     private static readonly RECONNECT_MAX_DELAY_MS;
     private static readonly RECONNECT_STATUS_EVERY_N;
     private isReconnecting;
+    private reconnectingAfterServerDisconnect;
+    /** Capped exponential backoff (2s, 4s, 8s, 16s, 32s, then 60s steady) shared
+     *  by both reconnect loops (connectAgent-RPC and server-disconnect). */
+    private static backoffDelayMs;
+    /** Sleep `ms`, unref'd so it never holds the process open on its own. */
+    private static delay;
     /**
      * Invoked after every successful session reconnect (the `connectAgent` RPC
      * re-established the session room). The runner uses this to force a TUI
@@ -133,6 +144,16 @@ declare class AgentConnection {
      */
     onReconnected?: () => void;
     private reconnectToSession;
+    /**
+     * Drive a bounded reconnect after a server-initiated disconnect. Loops until
+     * the socket reconnects or is torn down, nudging socket.connect() on each
+     * pass with a capped exponential backoff. A token refresh is attempted every
+     * pass (rate-limited to once/60s inside refreshTaskTokenFromBootstrap) but
+     * its result NEVER gates the reconnect — the socket must recover even when
+     * there is no fresh token to apply.
+     */
+    private scheduleReconnectAfterServerDisconnect;
+    private reconnectAfterServerDisconnect;
     private looksLikeAuthError;
     private startProactiveTokenRefresh;
     private stopProactiveTokenRefresh;
@@ -149,10 +170,19 @@ declare class AgentConnection {
     /**
      * Report that a same-pod review child failed to spawn (fire-and-forget).
      * The server Ends the orphaned review session and falls back to a dedicated
-     * review pod. sessionId is OUR (builder) session — the SEC-9 guard runs on
+     * review pod. sessionId is OUR (builder) session — the task-identity guard runs on
      * it; the review session is identified separately.
      */
     reportReviewSpawnFailure(reviewSessionId: string, error?: string): void;
+    /**
+     * Ask the server to destroy and recreate this pod (fire-and-forget). The
+     * agent calls this only when it has proven it cannot recover in place — the
+     * shared `~/.claude` GCS FUSE mount is dead and no in-container action can
+     * remount it. The server rate-limits the recycle and posts `reason` to the
+     * card; old servers that don't know the method reject harmlessly, leaving
+     * today's behavior (a failed turn with a chat warning).
+     */
+    requestWorkspaceRecycle(reason: string): void;
     onSpawnTui(callback: (data: SpawnTuiData) => void): void;
     /** Register the on-demand usage-refresh handler; drains an early-buffered
      *  `session:probeUsage` that arrived before the runner was ready. */
@@ -160,7 +190,7 @@ declare class AgentConnection {
     /**
      * Report that a same-pod TUI/shell child failed to spawn (fire-and-forget).
      * The server Ends the orphaned session — no fallback pod (unlike review).
-     * sessionId is OUR (builder) session — the SEC-9 guard runs on it.
+     * sessionId is OUR (builder) session — the task-identity guard runs on it.
      */
     reportSessionSpawnFailure(spawnedSessionId: string, error?: string): void;
     onRunStartCommand(callback: () => void): void;
@@ -186,6 +216,14 @@ declare class AgentConnection {
      * servers that don't know the method reject harmlessly.
      */
     sendPtyEnded(): void;
+    /**
+     * Report the port this pod's in-pod PTY stream server bound to, or null when
+     * it stopped (fire-and-forget). The server persists it so a viewer can be
+     * handed a port-scoped tunnel URL and stream the TUI straight from the pod.
+     * Old servers that don't know the method reject harmlessly — the session then
+     * just stays on the relay transport.
+     */
+    reportPtyStream(port: number | null): void;
     /** Subscribe to relayed keystrokes. Returns an unsubscribe fn. */
     onPtyInput(handler: (data: string) => void): () => void;
     /** Subscribe to relayed (reconciled) terminal resizes. Returns an unsubscribe fn. */
@@ -200,7 +238,24 @@ declare class AgentConnection {
         duplicate: true;
         matchedMessagePreview: string;
     };
-    sendHeartbeat(loopLagMs?: number): void;
+    /**
+     * @param loopStatus overrides the status derived from the last emitted
+     *   runner status. SessionRunner passes it so an idle runner that still has
+     *   background work outstanding in the pod beats as `waiting` (→ `active` on
+     *   the wire) rather than `idle`, which would let the workspace activity
+     *   clock expire mid-gate. See connection/loop-lag.ts `heartbeatStatusFor`.
+     *
+     * Without an override the status comes from `loopStatusForRunnerStatus`, the
+     * same total classifier SessionRunner uses, so both paths agree. This used to
+     * be a partial map covering 5 of the 11 `AgentRunnerStatus` values with a
+     * `?? "active"` fallback, which meant a parked runner (`waiting_for_input`,
+     * `finished`, `error`, `stopping`, `disconnected`) beat as ACTIVE on every
+     * no-arg call site — the reconnect paths below, and the shell/project/adhoc
+     * runners, which never pass a loop status at all. That renewed the workspace
+     * activity clock for an agent doing nothing, so the card stayed "active" and
+     * its pod stayed up long past the project's inactivity window.
+     */
+    sendHeartbeat(loopLagMs?: number, loopStatus?: LoopStatus): void;
     private heartbeatWorker;
     startHeartbeatWorker(sharedBuffer: SharedArrayBuffer, intervalMs?: number): void;
     stopHeartbeatWorker(): void;
@@ -217,6 +272,10 @@ declare class AgentConnection {
      *  Throws on failure so the PortDiscovery poller can retry on its next
      *  tick (a swallowed error here would silently drop the delta). */
     reportDiscoveredPorts(ports: WorkspaceDiscoveredPort[]): Promise<void>;
+    /** Boot-milestone report over the socket — the codespace-parity fallback
+     *  for the GKE pod bootstrap-token route. Fire-and-forget: a failed report
+     *  must never delay or fail the boot path. */
+    reportBootMilestone(key: string): void;
     sendTypingStart(): void;
     sendTypingStop(): void;
     emitRateLimitPause(resetsAt: string): void;
@@ -285,7 +344,14 @@ declare class AgentConnection {
         type: string;
         [key: string]: unknown;
     }): void;
+    /** Append (or, on `toFront`, prepend for a failed-flush re-queue) events to
+     *  the buffer, then cap + arm the flush timer. Single owner of the overflow
+     *  policy so append and re-queue can't diverge on the drop accounting. */
+    private enqueueEvents;
     flushEvents(): Promise<void>;
+    /** Put a failed flush's events back at the FRONT of the buffer, preserving
+     *  order, via the shared cap-and-arm path. */
+    private requeueFailedEvents;
 }
 
 type ModeAction = {
@@ -375,6 +441,11 @@ interface LifecycleConfig {
      *  the running subscription key. Deliberately NOT the heartbeat cadence — the
      *  endpoint is rate-limited. Set to `0` to disable the timer entirely. */
     usageSampleIntervalMs: number;
+    /** Delay before the FIRST usage sample (default: 30s). The sample spawns a
+     *  full `claude -p "/usage"` subprocess; sampling immediately at startup put
+     *  that CPU cost inside the boot-critical window on the throttled controller
+     *  container. Usage freshness 30s later costs nothing. */
+    usageSampleInitialDelayMs: number;
 }
 interface LifecycleCallbacks {
     onHeartbeat: () => void;
@@ -465,6 +536,9 @@ declare class SessionRunner {
     private dormantDeadline;
     private taskContext;
     private fullContext;
+    /** getTaskContext promise started in connect() so the longest server
+     *  roundtrip overlaps the room join + port scan; run() awaits it. */
+    private contextPrefetch;
     private queryBridge;
     private inputResolver;
     private pendingMessages;
@@ -478,12 +552,20 @@ declare class SessionRunner {
     private readonly portDiscovery;
     /** Main event-loop lag measurement, shared with the heartbeat worker. */
     private readonly loopLag;
+    /** Background work (a `run_in_background` gate, a backgrounded subagent) the
+     *  turn launched that is still running in the pod after the turn ended. While
+     *  it reports pending, heartbeats go out non-idle so the workspace activity
+     *  clock keeps being bumped and the reconciler can't sleep the pod mid-gate. */
+    private readonly backgroundWork;
     /** Boot supervisor handle, set post-construction once it's known (it is
      *  started alongside connect(), before the runner itself exists in some
      *  call sites) — notified when the core loop goes live so it can release
      *  the app's start command. Optional: never set in tests/paths that don't
      *  wire a supervisor. */
     private workspaceCommands;
+    /** Guards the one-shot `agent_live` boot-milestone report — fired on the
+     *  first harness event (createQueryBridge's onEvent hook). */
+    private agentLiveReported;
     constructor(config: SessionRunnerConfig, callbacks: SessionRunnerCallbacks, deps?: SessionRunnerDependencies);
     get state(): AgentRunnerStatus;
     get sessionId(): string;
@@ -498,6 +580,15 @@ declare class SessionRunner {
      * command output) before the main agent lifecycle begins.
      */
     connect(): Promise<boolean>;
+    /**
+     * The `connectAgent` handshake (joins the session room, drains pending
+     * messages), run concurrently with the preview-port baseline scan. Returns
+     * the server's pending messages, or `null` when the session is not authorized
+     * for the project — a permission denial no retry or token refresh can fix, so
+     * the caller parks cleanly rather than crash-looping. Any other error is
+     * rethrown (transient — the normal startup-failure path handles it).
+     */
+    private connectAgentSession;
     /**
      * Run the main agent lifecycle: fetch context, resolve mode, execute, loop.
      * Requires connect() to have been called first.
@@ -520,6 +611,21 @@ declare class SessionRunner {
     private handleDormantIdle;
     /** 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.
+     *
+     * 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.
+     */
+    private requeueWedgedInitialQuery;
     /**
      * Startup-queue preamble: the card's initial message reaches a fresh pod
      * twice — inside the task context (chat history) AND as a queued pending
@@ -593,10 +699,22 @@ declare class SessionRunner {
      *  `selectBestKey` rotation honest. Best-effort — never throws, no-op when the
      *  pod has no OAuth token (e.g. API-key projects). */
     private sampleAndReportKeyUsage;
+    /** Wait (bounded) for any in-flight periodic/turn flush to release the shared
+     *  guard, so a shutdown flush never races it on `.git/index.lock`. */
+    private waitForFlushSlot;
     /** Best-effort WIP commit + push on shutdown so in-flight work isn't lost
      *  when a claudespace pod is killed. Must be called BEFORE stop() so the
-     *  connection is still alive for token refresh. Never throws. */
+     *  connection is still alive for token refresh. Shares the in-flight guard
+     *  with the periodic/turn flushes (waits one out, then claims the slot) so a
+     *  SIGTERM mid-flush can't run two concurrent flushes racing the index lock.
+     *  Never throws. */
     flushGitOnShutdown(): Promise<void>;
+    /** Server-pushed `session:stop`: flush WIP BEFORE tearing down. Plain `stop()`
+     *  sets `stopped=true` and disconnects with no flush, losing everything since
+     *  the last periodic flush (≤2 min, up to ~20 min behind a gate-skipping
+     *  backstop). Flush while the connection is still alive (token refresh), then
+     *  stop. Idempotent + best-effort; `stop()` always runs. */
+    private stopWithFlush;
     stop(): void;
     softStop(): void;
     private buildFullContext;
@@ -606,6 +724,32 @@ declare class SessionRunner {
     private refreshGithubToken;
     /** Re-fetch task context to pick up a newly created branch and check it out. */
     private refreshBranchForBuilding;
+    /**
+     * The loop status the heartbeats should carry right now.
+     *
+     * `idle` requires BOTH a quiet runner and a quiet pod: an idle runner with a
+     * `run_in_background` gate still running reports `waiting`, which reaches the
+     * API as `active` and therefore bumps `Workspace.activityExpiresAt` (an idle
+     * heartbeat does not — `heartbeatBumps` is `status !== "idle"`). Without this
+     * the reconciler sleeps the pod one activity window after the turn ends and
+     * kills the gate. Note the runner's own `AgentRunnerStatus` stays `idle`:
+     * this is a liveness signal, not a UI one, so cards still read as idle.
+     *
+     * "Quiet runner" is `loopStatusForRunnerStatus`, NOT `_state === "idle"`.
+     * The old `_state !== "idle" → active` test made every parked state report
+     * work — above all `waiting_for_input`, a prefilled TUI sitting on a human,
+     * which renewed the clock on every beat and kept the card "active" on the
+     * board for the runner's whole 30-minute idle timer regardless of the
+     * project's inactivity window. See connection/loop-lag.ts for the table and
+     * for why an unknown status still fails open to `active`.
+     */
+    private resolveLoopStatus;
+    /** Mirror the resolved status into the loop-lag buffer so the starvation-proof
+     *  heartbeat worker reports it too. Returns what it wrote. */
+    private refreshLoopStatus;
+    /** One `tool_use` from the turn stream — registers a background launch when
+     *  the tool starts work that outlives the turn. */
+    private noteToolUseForBackgroundWork;
     private setState;
     private shutdown;
     private _finalState;
@@ -672,7 +816,6 @@ declare function detachWorktreeBranch(projectDir: string, branch: string): Promi
 declare function removeWorktree(projectDir: string, taskId: string): Promise<void>;
 
 interface ConveyorConfig {
-    setupCommand?: string;
     startCommand?: string;
 }
 interface ForwardPortsResult {
@@ -683,7 +826,9 @@ interface ForwardPortsResult {
     }>;
 }
 declare function loadForwardPorts(workspaceDir: string): Promise<ForwardPortsResult>;
-/** Load config from env vars (project-level settings injected via bootstrap). */
+/** Load config from env vars (project-level settings injected via bootstrap).
+ *  Note: the project's setupCommand runs at image-bake time (server-side Cloud
+ *  Build) and is never delivered to pods — only startCommand arrives via env. */
 declare function loadConveyorConfig(): ConveyorConfig | null;
 
 declare function runSetupCommand(cmd: string, cwd: string, onOutput: (stream: "stdout" | "stderr", data: string) => void, signal?: AbortSignal): Promise<void>;

package/dist/index.js

@@ -13,12 +13,12 @@ import {
   unshallowRepo,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-3GDXX3OX.js";
-import "./chunk-7TQO4ZF4.js";
+} from "./chunk-36VMMHYD.js";
+import "./chunk-KCB7CSWJ.js";
+import "./chunk-5OQQSDVT.js";
 import {
   getWorkbenchClient
-} from "./chunk-UDSRAHKP.js";
-import "./chunk-UZTJJD7Y.js";
+} from "./chunk-QOJTJCYZ.js";
 import {
   workbenchEnabled
 } from "./chunk-4VUQ2NPF.js";
@@ -26,7 +26,7 @@ import {
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand
-} from "./chunk-72AEN6LB.js";
+} from "./chunk-XR6H326I.js";
 import "./chunk-JIGG755T.js";
 
 // src/runner/worktree.ts

package/dist/oom-watchdog-U7JERHA2.js

@@ -0,0 +1,11 @@
+import {
+  biggestForeignProcessGroup,
+  oomWatchdogOptionsFromEnv,
+  startOomWatchdog
+} from "./chunk-ULS4QPRE.js";
+export {
+  biggestForeignProcessGroup,
+  oomWatchdogOptionsFromEnv,
+  startOomWatchdog
+};
+//# sourceMappingURL=oom-watchdog-U7JERHA2.js.map

package/dist/server-NIOBJ46G.js

@@ -0,0 +1,10 @@
+import {
+  startWorkbenchServer
+} from "./chunk-3Z4YQNJV.js";
+import "./chunk-XR6H326I.js";
+import "./chunk-JIGG755T.js";
+import "./chunk-ULS4QPRE.js";
+export {
+  startWorkbenchServer
+};
+//# sourceMappingURL=server-NIOBJ46G.js.map

package/dist/server-NIOBJ46G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "10.13.18",
+  "version": "10.13.50",
   "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",
@@ -27,7 +27,7 @@
     "prepublishOnly": "tsup",
     "build": "tsup",
     "build:js": "tsup --no-dts --no-clean",
-    "dev": "tsup --watch --no-dts",
+    "dev": "tsup --watch --no-dts --no-clean",
     "test": "vitest run --passWithNoTests",
     "test:unit": "vitest run --passWithNoTests",
     "test:watch": "vitest",
@@ -36,7 +36,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.197",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.219",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "node-pty": "^1.0.0",
     "socket.io-client": "^4.8.3",

package/runtime/entrypoint.sh

@@ -1,11 +1,12 @@
 #!/bin/sh
 # vnext shim — ALL boot logic lives in `conveyor-agent boot`
-# (packages/conveyor-agent/src/boot/). Keep this file dumb: env floor,
-# best-effort self-update preflight, exec. The preflight runs baked code and
-# only installs; the exec picks up whichever global bin is now current.
+# (packages/conveyor-agent/src/boot/). Keep this file dumb: env floor, exec.
+# The npm self-update preflight is no longer a separate blocking process here —
+# `conveyor-agent boot` runs it concurrently with the boot pipeline and gates
+# only the runner spawn / workbench daemon on the result (self-update.ts), so
+# each container saves a full node+npm process launch on the boot critical path.
 set -eu
 export HOME=/home/conveyor
 export PATH="/home/conveyor/.bun/bin:${PATH}"
 export NO_UPDATE_NOTIFIER=1
-conveyor-agent boot --preflight-update || echo "[shim] preflight failed; booting baked agent"
 exec conveyor-agent boot