@rallycry/conveyor-agent 10.2.2 → 10.2.4

package/dist/heartbeat-worker.js

@@ -0,0 +1,47 @@
+import {
+  lagFromBuffer,
+  statusFromBuffer
+} from "./chunk-7TQO4ZF4.js";
+
+// src/connection/heartbeat-worker.ts
+import { parentPort, workerData } from "worker_threads";
+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" }
+});
+parentPort?.on("message", (msg) => {
+  if (msg?.taskToken) taskToken = msg.taskToken;
+});
+socket.on("disconnect", (reason) => {
+  if (reason === "io server disconnect" || reason === "server namespace disconnect") {
+    socket.connect();
+  }
+});
+function beat() {
+  if (!socket.connected) return;
+  socket.emit(
+    "agentSessionService:heartbeat",
+    {
+      sessionId: data.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: statusFromBuffer(view),
+      loopLagMs: Math.round(lagFromBuffer(view))
+    },
+    // Ack intentionally ignored: a missed beat self-heals on the next tick,
+    // and the worker must never accumulate state or throw.
+    () => {
+    }
+  );
+}
+setInterval(beat, data.intervalMs);
+//# sourceMappingURL=heartbeat-worker.js.map

package/dist/heartbeat-worker.js.map

@@ -0,0 +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":[]}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _project_shared from '@project/shared';
-import { RunnerMode, AgentSessionServiceMethods, AgentMode, WorkspaceDiscoveredPort, AgentQuestion, AgentRunnerStatus, BootstrapBundle } from '@project/shared';
+import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload, WorkspaceDiscoveredPort, AgentQuestion, AgentRunnerStatus, BootstrapBundle } from '@project/shared';
 export * from '@project/shared';
 import { ChildProcess } from 'node:child_process';
 
@@ -143,6 +143,12 @@ declare class AgentConnection {
         cols: number;
         rows: number;
     }): void;
+    /**
+     * Forward one compact chat-proxy event derived from the transcript JSONL to
+     * the relay (fire-and-forget). Feeds the experimental chat PTY proxy ring.
+     * Old servers that don't know the method reject harmlessly.
+     */
+    sendPtyChatEvent(event: PtyChatEventPayload): void;
     /**
      * Report that the interactive CLI process for this session has died and no
      * respawn is imminent (fire-and-forget). The server clears the scrollback
@@ -164,7 +170,10 @@ declare class AgentConnection {
         duplicate: true;
         matchedMessagePreview: string;
     };
-    sendHeartbeat(): void;
+    sendHeartbeat(loopLagMs?: number): void;
+    private heartbeatWorker;
+    startHeartbeatWorker(sharedBuffer: SharedArrayBuffer, intervalMs?: number): void;
+    stopHeartbeatWorker(): void;
     emitModeChanged(agentMode?: AgentMode | null): void;
     updateTaskFields(fields: {
         plan?: string;
@@ -409,8 +418,14 @@ declare class SessionRunner {
     private agentSpokeThisTurn;
     /** Guards overlapping runs of the periodic git flush. */
     private periodicFlushInFlight;
+    /** Consecutive flush ticks skipped because a heavy gate was running. */
+    private gateSkipCount;
+    /** Max consecutive gate-deferred ticks (~2 min each) before flushing anyway. */
+    private static readonly MAX_GATE_SKIPS;
     /** Runtime preview-port poller (v3 dynamic port discovery). */
     private portDiscovery;
+    /** Main event-loop lag measurement, shared with the heartbeat worker. */
+    private readonly loopLag;
     constructor(config: SessionRunnerConfig, callbacks: SessionRunnerCallbacks);
     get state(): AgentRunnerStatus;
     get sessionId(): string;
@@ -508,16 +523,27 @@ declare class SessionRunner {
     stop(): void;
     softStop(): void;
     private static readonly MAX_STUCK_NUDGES;
-    /** The prompt delivered into the live TUI when an auto agent looks stuck. It
-     *  must offer BOTH escape routes so the agent never just goes idle. */
+    /** The build-phase nudge (In Progress, no PR). Offers BOTH escape routes so
+     *  the agent never just goes idle. */
     private static readonly STUCK_PROMPT;
+    /** The planning-phase nudge (still Planning, identification/plan unfinished).
+     *  Same two-escape-route shape, aimed at finishing discovery instead of a PR. */
+    private static readonly STUCK_PROMPT_PLANNING;
     /**
-     * An auto task is "stuck" when its last turn ended (the call sites run
-     * post-turn, so the TUI is no longer actively working), it has no open PR,
-     * AND the agent did not communicate in chat this turn. If the agent posted a
-     * message (explained itself / asked for help) it is waiting on a human, not
-     * silently stuck, so we leave it attached instead of nudging.
+     * Classify how an auto task is "stuck" after its turn ended (call sites run
+     * post-turn, so the TUI is no longer working), or null if it isn't. Shared
+     * guards: only auto, not rate-limited, under the nudge cap, and the agent
+     * stayed silent this turn — if it posted to chat (explained itself / asked for
+     * help) it's waiting on a human, not silently stuck.
+     *
+     * - "pr":       In Progress with no open PR (build finished without shipping).
+     * - "planning": still Planning without (identified + saved plan). A fresh auto
+     *   agent that finishes its plan turn WITHOUT ExitPlanMode would otherwise idle
+     *   → clean-exit → its session Ends → the workspace is reaped "agent_gone"
+     *   before a plan ever landed. Nudging (and, on exhaustion, going dormant)
+     *   keeps the session Active so the pod is never prematurely slept.
      */
+    private autoStuckKind;
     private isAutoStuck;
     /**
      * Stop driving the agent and route the core loop into dormant idle —
@@ -528,15 +554,18 @@ declare class SessionRunner {
      */
     private enterDormantForHumanTakeover;
     private refreshTaskContext;
+    /** Prompt + chat-message label for a stuck-nudge of the given kind. */
+    private stuckNudgeContent;
     private maybeHandleStuckAuto;
     private buildFullContext;
     private createQueryBridge;
     private wireConnectionCallbacks;
     /** Eager finalize snapshot triggered by the reconciler's sleep signal
-     *  (session:finalizeSnapshot). Runs pg_dump + a full capture and uploads it
+     *  (session:finalizeSnapshot). Runs a full workspace capture and uploads it
      *  NOW so the sleep confirms on this snapshot instead of waiting for the
-     *  ~2min periodic flush — and so sidecar DB state (which ONLY finalizeForSleep
-     *  captures via pg_dump) actually lands. Best-effort: on failure the
+     *  ~2min periodic flush. Sidecar DB state is intentionally NOT captured — it
+     *  is no longer durable across sleep/wake (#2623); only the agent's
+     *  /workspace rides the snapshot. Best-effort: on failure the
      *  periodic/shutdown path stays the fallback. No-op on non-v3 pods. */
     private finalizeSnapshotNow;
     /** Proactively refresh the GitHub token before the 1-hour expiry. */
@@ -569,29 +598,16 @@ interface AgentRunnerCallbacks {
     onStatusChange: (status: string) => void | Promise<void>;
 }
 
-declare class PlanSync {
-    private planFileSnapshot;
-    private lockedPlanFile;
-    private workspaceDir;
-    private connection;
-    constructor(workspaceDir: string, connection: AgentConnection);
-    updateWorkspaceDir(workspaceDir: string): void;
-    private getPlanDirs;
-    snapshotPlanFiles(): void;
-    private findNewestPlanFile;
-    syncPlanFile(): Promise<void>;
-}
-
 /** Returns true if the working tree has uncommitted changes (staged or unstaged). */
-declare function hasUncommittedChanges(cwd: string): boolean;
+declare function hasUncommittedChanges(cwd: string): Promise<boolean>;
 /** Returns the current branch name, or null if on detached HEAD. */
-declare function getCurrentBranch(cwd: string): string | null;
+declare function getCurrentBranch(cwd: string): Promise<string | null>;
 /** Returns true if there are committed changes that haven't been pushed to origin. */
-declare function hasUnpushedCommits(cwd: string): boolean;
+declare function hasUnpushedCommits(cwd: string): Promise<boolean>;
 /** Stage all changes and create a commit. Returns the commit hash if successful. */
-declare function stageAndCommit(cwd: string, message: string): string | null;
+declare function stageAndCommit(cwd: string, message: string): Promise<string | null>;
 /** Update the git remote URL with a fresh token. */
-declare function updateRemoteToken(cwd: string, token: string): void;
+declare function updateRemoteToken(cwd: string, token: string): Promise<void>;
 /** Best-effort flush of pending work: pushes any real (intentional) commits to
  *  the task branch, and captures uncommitted changes as a WIP snapshot on the
  *  `conveyor-wip/<branch>` ref — never as commits on the branch itself. When
@@ -608,18 +624,18 @@ declare function flushPendingChanges(cwd: string, opts?: {
  *  attempting the push. On auth failure, refreshes again and retries. */
 declare function pushToOrigin(cwd: string, refreshToken?: () => Promise<string | undefined>, skipVerify?: boolean): Promise<boolean>;
 
-declare function ensureWorktree(projectDir: string, taskId: string, branch?: string): string;
+declare function ensureWorktree(projectDir: string, taskId: string, branch?: string): Promise<string>;
 /**
  * Detach any task worktree that has `branch` checked out, releasing the branch lock
  * so the main project directory can check it out. Only touches worktrees inside
  * `.worktrees/` — never the main project directory.
  */
-declare function detachWorktreeBranch(projectDir: string, branch: string): void;
+declare function detachWorktreeBranch(projectDir: string, branch: string): Promise<void>;
 /**
  * Force-remove is intentional: this runs after task completion or explicit stop.
  * Any uncommitted changes at this point are scratch artifacts, not valuable work.
  */
-declare function removeWorktree(projectDir: string, taskId: string): void;
+declare function removeWorktree(projectDir: string, taskId: string): Promise<void>;
 
 interface CaptureContext {
     cwd: string;
@@ -627,9 +643,6 @@ interface CaptureContext {
     snapshotUploadUrl?: string;
     refreshToken?: () => Promise<string | undefined>;
     wipMessage?: string;
-    /** Path to a pre-built postgres dump OUTSIDE cwd (see pg-dump.ts) that the
-     *  GCS tar should carry under its fixed in-archive name. */
-    pgDumpPath?: string;
     /** Force the GCS PUT even when the tar is empty (sizeBytes === 0). Used by the
      *  sleep FINALIZE path so `snapshotAt` is stamped and the reconciler's
      *  teardown confirm lands immediately — an empty workspace is a valid (empty)
@@ -644,8 +657,6 @@ interface SnapshotArtifact {
     sizeBytes: number;
     gcsUploaded: boolean;
     wipPushed: boolean;
-    /** Whether this capture bundled a postgres dump into the GCS artifact. */
-    pgDumped: boolean;
 }
 interface RestoreResult {
     source: "gcs" | "wip" | "clean";
@@ -656,7 +667,6 @@ interface GcsUploadResult {
     fileCount: number;
     deletionCount: number;
     sizeBytes: number;
-    pgDumped: boolean;
 }
 /**
  * The GCS sink on its own: assemble the snapshot tar (the single capture
@@ -667,7 +677,6 @@ interface GcsUploadResult {
  * after any earlier in-flight one has settled.
  */
 declare function uploadSnapshotToGcs(cwd: string, uploadUrl: string | undefined, opts?: {
-    pgDumpPath?: string;
     forceUpload?: boolean;
 }): Promise<GcsUploadResult>;
 declare function captureSnapshot(ctx: CaptureContext): Promise<SnapshotArtifact>;
@@ -692,7 +701,6 @@ declare function restoreOnBoot(bundle: Pick<BootstrapBundle, "snapshotUrl"> & {
 interface ConveyorConfig {
     setupCommand?: string;
     startCommand?: string;
-    previewPort?: number;
 }
 interface ForwardPortsResult {
     ports: number[];
@@ -712,4 +720,4 @@ declare function runStartCommand(cmd: string, cwd: string, onOutput: (stream: "s
 /** Fetch full git history if the repo was cloned with --depth=1. */
 declare function unshallowRepo(workspaceDir: string): void;
 
-export { AgentConnection, type AgentConnectionConfig, type AgentRunnerCallbacks, type AgentRunnerConfig, type ApiKeyUpdateData, type CaptureContext, type ConveyorConfig, type GcsUploadResult, type IncomingMessage, type LifecycleCallbacks, type LifecycleConfig, type ModeAction, type ModeTaskContext, PlanSync, type RestoreResult, SessionRunner, type SessionRunnerCallbacks, type SessionRunnerConfig, type SetModeData, type SnapshotArtifact, captureSnapshot, detachWorktreeBranch, ensureWorktree, finalizeForSleep, flushPendingChanges, getCurrentBranch, hasUncommittedChanges, hasUnpushedCommits, loadConveyorConfig, loadForwardPorts, pushToOrigin, removeWorktree, restoreOnBoot, runAuthTokenCommand, runSetupCommand, runStartCommand, stageAndCommit, startPeriodic as startWorkPreservation, stop as stopWorkPreservation, unshallowRepo, updateRemoteToken, uploadSnapshotToGcs };
+export { AgentConnection, type AgentConnectionConfig, type AgentRunnerCallbacks, type AgentRunnerConfig, type ApiKeyUpdateData, type CaptureContext, type ConveyorConfig, type GcsUploadResult, type IncomingMessage, type LifecycleCallbacks, type LifecycleConfig, type ModeAction, type ModeTaskContext, type RestoreResult, SessionRunner, type SessionRunnerCallbacks, type SessionRunnerConfig, type SetModeData, type SnapshotArtifact, captureSnapshot, detachWorktreeBranch, ensureWorktree, finalizeForSleep, flushPendingChanges, getCurrentBranch, hasUncommittedChanges, hasUnpushedCommits, loadConveyorConfig, loadForwardPorts, pushToOrigin, removeWorktree, restoreOnBoot, runAuthTokenCommand, runSetupCommand, runStartCommand, stageAndCommit, startPeriodic as startWorkPreservation, stop as stopWorkPreservation, unshallowRepo, updateRemoteToken, uploadSnapshotToGcs };

package/dist/index.js

@@ -1,6 +1,5 @@
 import {
   AgentConnection,
-  PlanSync,
   SessionRunner,
   captureSnapshot,
   finalizeForSleep,
@@ -21,46 +20,45 @@ import {
   unshallowRepo,
   updateRemoteToken,
   uploadSnapshotToGcs
-} from "./chunk-53ZLFIAI.js";
+} from "./chunk-DEMRCBJN.js";
+import "./chunk-7TQO4ZF4.js";
 
 // src/runner/worktree.ts
-import { execSync } from "child_process";
+import { execFile } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 6e4;
+async function git(cwd, args) {
+  const { stdout } = await execFileAsync("git", args, { cwd, timeout: GIT_TIMEOUT_MS });
+  return stdout.toString();
+}
 var WORKTREE_DIR = ".worktrees";
-function ensureWorktree(projectDir, taskId, branch) {
+async function ensureWorktree(projectDir, taskId, branch) {
   if (projectDir.includes(`/${WORKTREE_DIR}/`)) {
     return projectDir;
   }
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (existsSync(worktreePath)) {
     if (branch) {
-      if (hasUncommittedChanges(worktreePath)) {
+      if (await hasUncommittedChanges(worktreePath)) {
         return worktreePath;
       }
       try {
-        execSync(`git checkout --detach origin/${branch}`, {
-          cwd: worktreePath,
-          stdio: "ignore"
-        });
+        await git(worktreePath, ["checkout", "--detach", `origin/${branch}`]);
       } catch {
       }
     }
     return worktreePath;
   }
   const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync(`git worktree add --detach "${worktreePath}" ${ref}`, {
-    cwd: projectDir,
-    stdio: "ignore"
-  });
+  await git(projectDir, ["worktree", "add", "--detach", worktreePath, ref]);
   return worktreePath;
 }
-function detachWorktreeBranch(projectDir, branch) {
+async function detachWorktreeBranch(projectDir, branch) {
   try {
-    const output = execSync("git worktree list --porcelain", {
-      cwd: projectDir,
-      encoding: "utf-8"
-    });
+    const output = await git(projectDir, ["worktree", "list", "--porcelain"]);
     const entries = output.split("\n\n");
     for (const entry of entries) {
       const lines = entry.trim().split("\n");
@@ -70,27 +68,23 @@ function detachWorktreeBranch(projectDir, branch) {
       const worktreePath = worktreeLine.replace("worktree ", "");
       if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;
       try {
-        execSync("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
+        await git(worktreePath, ["checkout", "--detach"]);
       } catch {
       }
     }
   } catch {
   }
 }
-function removeWorktree(projectDir, taskId) {
+async function removeWorktree(projectDir, taskId) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync(worktreePath)) return;
   try {
-    execSync(`git worktree remove "${worktreePath}" --force`, {
-      cwd: projectDir,
-      stdio: "ignore"
-    });
+    await git(projectDir, ["worktree", "remove", worktreePath, "--force"]);
   } catch {
   }
 }
 export {
   AgentConnection,
-  PlanSync,
   SessionRunner,
   captureSnapshot,
   detachWorktreeBranch,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner/worktree.ts"],"sourcesContent":["import { execSync } from \"node:child_process\";\nimport { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { hasUncommittedChanges } from \"./git-utils.js\";\n\nconst WORKTREE_DIR = \".worktrees\";\n\nexport function ensureWorktree(projectDir: string, taskId: string, branch?: string): string {\n  if (projectDir.includes(`/${WORKTREE_DIR}/`)) {\n    return projectDir;\n  }\n\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n\n  if (existsSync(worktreePath)) {\n    if (branch) {\n      if (hasUncommittedChanges(worktreePath)) {\n        return worktreePath;\n      }\n      try {\n        execSync(`git checkout --detach origin/${branch}`, {\n          cwd: worktreePath,\n          stdio: \"ignore\",\n        });\n      } catch {\n        /* branch doesn't exist on remote yet */\n      }\n    }\n    return worktreePath;\n  }\n\n  const ref = branch ? `origin/${branch}` : \"HEAD\";\n  execSync(`git worktree add --detach \"${worktreePath}\" ${ref}`, {\n    cwd: projectDir,\n    stdio: \"ignore\",\n  });\n\n  return worktreePath;\n}\n\n/**\n * Detach any task worktree that has `branch` checked out, releasing the branch lock\n * so the main project directory can check it out. Only touches worktrees inside\n * `.worktrees/` — never the main project directory.\n */\nexport function detachWorktreeBranch(projectDir: string, branch: string): void {\n  try {\n    const output = execSync(\"git worktree list --porcelain\", {\n      cwd: projectDir,\n      encoding: \"utf-8\",\n    });\n    const entries = output.split(\"\\n\\n\");\n    for (const entry of entries) {\n      const lines = entry.trim().split(\"\\n\");\n      const worktreeLine = lines.find((l) => l.startsWith(\"worktree \"));\n      const branchLine = lines.find((l) => l.startsWith(\"branch \"));\n      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;\n\n      const worktreePath = worktreeLine.replace(\"worktree \", \"\");\n      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;\n\n      try {\n        execSync(\"git checkout --detach\", { cwd: worktreePath, stdio: \"ignore\" });\n      } catch {\n        /* best effort */\n      }\n    }\n  } catch {\n    /* best effort */\n  }\n}\n\n/**\n * Force-remove is intentional: this runs after task completion or explicit stop.\n * Any uncommitted changes at this point are scratch artifacts, not valuable work.\n */\nexport function removeWorktree(projectDir: string, taskId: string): void {\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n  if (!existsSync(worktreePath)) return;\n  try {\n    execSync(`git worktree remove \"${worktreePath}\" --force`, {\n      cwd: projectDir,\n      stdio: \"ignore\",\n    });\n  } catch {\n    /* best effort */\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,YAAY;AAGrB,IAAM,eAAe;AAEd,SAAS,eAAe,YAAoB,QAAgB,QAAyB;AAC1F,MAAI,WAAW,SAAS,IAAI,YAAY,GAAG,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAE1D,MAAI,WAAW,YAAY,GAAG;AAC5B,QAAI,QAAQ;AACV,UAAI,sBAAsB,YAAY,GAAG;AACvC,eAAO;AAAA,MACT;AACA,UAAI;AACF,iBAAS,gCAAgC,MAAM,IAAI;AAAA,UACjD,KAAK;AAAA,UACL,OAAO;AAAA,QACT,CAAC;AAAA,MACH,QAAQ;AAAA,MAER;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,SAAS,UAAU,MAAM,KAAK;AAC1C,WAAS,8BAA8B,YAAY,KAAK,GAAG,IAAI;AAAA,IAC7D,KAAK;AAAA,IACL,OAAO;AAAA,EACT,CAAC;AAED,SAAO;AACT;AAOO,SAAS,qBAAqB,YAAoB,QAAsB;AAC7E,MAAI;AACF,UAAM,SAAS,SAAS,iCAAiC;AAAA,MACvD,KAAK;AAAA,MACL,UAAU;AAAA,IACZ,CAAC;AACD,UAAM,UAAU,OAAO,MAAM,MAAM;AACnC,eAAW,SAAS,SAAS;AAC3B,YAAM,QAAQ,MAAM,KAAK,EAAE,MAAM,IAAI;AACrC,YAAM,eAAe,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,WAAW,CAAC;AAChE,YAAM,aAAa,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,CAAC;AAC5D,UAAI,CAAC,gBAAgB,eAAe,qBAAqB,MAAM,GAAI;AAEnE,YAAM,eAAe,aAAa,QAAQ,aAAa,EAAE;AACzD,UAAI,CAAC,aAAa,SAAS,IAAI,YAAY,GAAG,EAAG;AAEjD,UAAI;AACF,iBAAS,yBAAyB,EAAE,KAAK,cAAc,OAAO,SAAS,CAAC;AAAA,MAC1E,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACF;AAMO,SAAS,eAAe,YAAoB,QAAsB;AACvE,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAC1D,MAAI,CAAC,WAAW,YAAY,EAAG;AAC/B,MAAI;AACF,aAAS,wBAAwB,YAAY,aAAa;AAAA,MACxD,KAAK;AAAA,MACL,OAAO;AAAA,IACT,CAAC;AAAA,EACH,QAAQ;AAAA,EAER;AACF;","names":[]}
+{"version":3,"sources":["../src/runner/worktree.ts"],"sourcesContent":["import { execFile } from \"node:child_process\";\nimport { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { hasUncommittedChanges } from \"./git-utils.js\";\n\n// Async git (execFile, no shell) — synchronous child processes freeze the\n// agent's event loop and starve the socket heartbeat; see git-utils.ts.\nconst execFileAsync = promisify(execFile);\nconst GIT_TIMEOUT_MS = 60_000;\n\nasync function git(cwd: string, args: string[]): Promise<string> {\n  const { stdout } = await execFileAsync(\"git\", args, { cwd, timeout: GIT_TIMEOUT_MS });\n  return stdout.toString();\n}\n\nconst WORKTREE_DIR = \".worktrees\";\n\nexport async function ensureWorktree(\n  projectDir: string,\n  taskId: string,\n  branch?: string,\n): Promise<string> {\n  if (projectDir.includes(`/${WORKTREE_DIR}/`)) {\n    return projectDir;\n  }\n\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n\n  if (existsSync(worktreePath)) {\n    if (branch) {\n      if (await hasUncommittedChanges(worktreePath)) {\n        return worktreePath;\n      }\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\", `origin/${branch}`]);\n      } catch {\n        /* branch doesn't exist on remote yet */\n      }\n    }\n    return worktreePath;\n  }\n\n  const ref = branch ? `origin/${branch}` : \"HEAD\";\n  await git(projectDir, [\"worktree\", \"add\", \"--detach\", worktreePath, ref]);\n\n  return worktreePath;\n}\n\n/**\n * Detach any task worktree that has `branch` checked out, releasing the branch lock\n * so the main project directory can check it out. Only touches worktrees inside\n * `.worktrees/` — never the main project directory.\n */\nexport async function detachWorktreeBranch(projectDir: string, branch: string): Promise<void> {\n  try {\n    const output = await git(projectDir, [\"worktree\", \"list\", \"--porcelain\"]);\n    const entries = output.split(\"\\n\\n\");\n    for (const entry of entries) {\n      const lines = entry.trim().split(\"\\n\");\n      const worktreeLine = lines.find((l) => l.startsWith(\"worktree \"));\n      const branchLine = lines.find((l) => l.startsWith(\"branch \"));\n      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;\n\n      const worktreePath = worktreeLine.replace(\"worktree \", \"\");\n      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;\n\n      try {\n        await git(worktreePath, [\"checkout\", \"--detach\"]);\n      } catch {\n        /* best effort */\n      }\n    }\n  } catch {\n    /* best effort */\n  }\n}\n\n/**\n * Force-remove is intentional: this runs after task completion or explicit stop.\n * Any uncommitted changes at this point are scratch artifacts, not valuable work.\n */\nexport async function removeWorktree(projectDir: string, taskId: string): Promise<void> {\n  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);\n  if (!existsSync(worktreePath)) return;\n  try {\n    await git(projectDir, [\"worktree\", \"remove\", worktreePath, \"--force\"]);\n  } catch {\n    /* best effort */\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAK1B,IAAM,gBAAgB,UAAU,QAAQ;AACxC,IAAM,iBAAiB;AAEvB,eAAe,IAAI,KAAa,MAAiC;AAC/D,QAAM,EAAE,OAAO,IAAI,MAAM,cAAc,OAAO,MAAM,EAAE,KAAK,SAAS,eAAe,CAAC;AACpF,SAAO,OAAO,SAAS;AACzB;AAEA,IAAM,eAAe;AAErB,eAAsB,eACpB,YACA,QACA,QACiB;AACjB,MAAI,WAAW,SAAS,IAAI,YAAY,GAAG,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAE1D,MAAI,WAAW,YAAY,GAAG;AAC5B,QAAI,QAAQ;AACV,UAAI,MAAM,sBAAsB,YAAY,GAAG;AAC7C,eAAO;AAAA,MACT;AACA,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,YAAY,UAAU,MAAM,EAAE,CAAC;AAAA,MACtE,QAAQ;AAAA,MAER;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,SAAS,UAAU,MAAM,KAAK;AAC1C,QAAM,IAAI,YAAY,CAAC,YAAY,OAAO,YAAY,cAAc,GAAG,CAAC;AAExE,SAAO;AACT;AAOA,eAAsB,qBAAqB,YAAoB,QAA+B;AAC5F,MAAI;AACF,UAAM,SAAS,MAAM,IAAI,YAAY,CAAC,YAAY,QAAQ,aAAa,CAAC;AACxE,UAAM,UAAU,OAAO,MAAM,MAAM;AACnC,eAAW,SAAS,SAAS;AAC3B,YAAM,QAAQ,MAAM,KAAK,EAAE,MAAM,IAAI;AACrC,YAAM,eAAe,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,WAAW,CAAC;AAChE,YAAM,aAAa,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,CAAC;AAC5D,UAAI,CAAC,gBAAgB,eAAe,qBAAqB,MAAM,GAAI;AAEnE,YAAM,eAAe,aAAa,QAAQ,aAAa,EAAE;AACzD,UAAI,CAAC,aAAa,SAAS,IAAI,YAAY,GAAG,EAAG;AAEjD,UAAI;AACF,cAAM,IAAI,cAAc,CAAC,YAAY,UAAU,CAAC;AAAA,MAClD,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACF;AAMA,eAAsB,eAAe,YAAoB,QAA+B;AACtF,QAAM,eAAe,KAAK,YAAY,cAAc,MAAM;AAC1D,MAAI,CAAC,WAAW,YAAY,EAAG;AAC/B,MAAI;AACF,UAAM,IAAI,YAAY,CAAC,YAAY,UAAU,cAAc,SAAS,CAAC;AAAA,EACvE,QAAQ;AAAA,EAER;AACF;","names":[]}

package/package.json

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