@rallycry/conveyor-agent 10.2.2 → 10.2.5

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-CFELRV35.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.5",
   "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/runtime/entrypoint.sh

@@ -324,6 +324,13 @@ if [ -n "${CONVEYOR_USER_ID}" ] && [ -n "${USER_HOME_PROJECT_ID}" ] && [ -d "${U
   ln -sfn "${USER_HOME_ROOT}/.claude"        /home/conveyor/.claude
   ln -sfn "${USER_HOME_ROOT}/.claude.json"   /home/conveyor/.claude.json
   ln -sfn "${USER_HOME_ROOT}/.config/claude" /home/conveyor/.config/claude
+
+  # OpenCode state (sessions + config) persists the same way as ~/.claude.
+  mkdir -p "${USER_HOME_ROOT}/.local/share/opencode" "${USER_HOME_ROOT}/.config/opencode" 2>/dev/null || true
+  rm -rf /home/conveyor/.local/share/opencode /home/conveyor/.config/opencode 2>/dev/null || true
+  mkdir -p /home/conveyor/.local/share 2>/dev/null || true
+  ln -sfn "${USER_HOME_ROOT}/.local/share/opencode" /home/conveyor/.local/share/opencode
+  ln -sfn "${USER_HOME_ROOT}/.config/opencode"      /home/conveyor/.config/opencode
 else
   echo "[pool] Skipping user-home symlink (userId='${CONVEYOR_USER_ID}', projectId='${USER_HOME_PROJECT_ID}', mount present: $([ -d "${USER_HOME_MOUNT}" ] && echo yes || echo no))"
   # No persistent home — the CLI reads the pod-local config; seed it there so
@@ -331,6 +338,88 @@ else
   seed_claude_json /home/conveyor/.claude.json
 fi
 
+# ── Wire published graphify bundles from the shared user-home mount ──
+# A locally published graph lives in the same GCS-FUSE user-home bucket as
+# Claude state, under users/_shared/graphify/<repo>/latest. Export the path
+# contract before the agent starts, then bind the files into graphify-out after
+# git has prepared the workspace but before the ready marker is released.
+configure_graphify_env() {
+  if [ "${CONVEYOR_GRAPHIFY_DISABLE:-}" = "1" ]; then
+    return 0
+  fi
+
+  local slug="${CONVEYOR_GRAPHIFY_SLUG:-${REPO_NAME:-}}"
+  if [ -z "${slug}" ]; then
+    return 0
+  fi
+
+  local primary_root="${USER_HOME_MOUNT}/users/_shared/graphify"
+  local legacy_root="${USER_HOME_MOUNT}/_shared/graphify"
+  local shared_root="${CONVEYOR_GRAPHIFY_SHARED_ROOT:-}"
+  if [ -z "${shared_root}" ]; then
+    if [ -d "${primary_root}" ] || [ ! -d "${legacy_root}" ]; then
+      shared_root="${primary_root}"
+    else
+      shared_root="${legacy_root}"
+    fi
+  fi
+
+  export CONVEYOR_GRAPHIFY_SLUG="${slug}"
+  export CONVEYOR_GRAPHIFY_SHARED_ROOT="${shared_root}"
+  export CONVEYOR_GRAPHIFY_DIR="${CONVEYOR_GRAPHIFY_DIR:-${shared_root}/${slug}/latest}"
+  export CONVEYOR_GRAPHIFY_GRAPH="${CONVEYOR_GRAPHIFY_GRAPH:-${CONVEYOR_GRAPHIFY_DIR}/graph.json}"
+}
+
+bind_graphify_bundle() {
+  if [ "${CONVEYOR_GRAPHIFY_DISABLE:-}" = "1" ]; then
+    echo "[pool] Graphify bind disabled."
+    return 0
+  fi
+
+  if [ -z "${CONVEYOR_GRAPHIFY_SLUG:-}" ]; then
+    return 0
+  fi
+
+  local workspace="${CONVEYOR_WORKSPACE:-/workspaces/repo}"
+  local source_dir="${CONVEYOR_GRAPHIFY_DIR:-}"
+  local graph_file="${CONVEYOR_GRAPHIFY_GRAPH:-}"
+
+  if [ -z "${source_dir}" ] || [ -z "${graph_file}" ]; then
+    return 0
+  fi
+
+  if [ ! -f "${graph_file}" ]; then
+    echo "[pool] Graphify bundle not found for '${CONVEYOR_GRAPHIFY_SLUG}' at ${source_dir}"
+    return 0
+  fi
+
+  local target_dir="${workspace}/graphify-out"
+  if ! mkdir -p "${target_dir}" 2>/dev/null; then
+    echo "[pool] WARN: unable to create graphify-out at ${target_dir}"
+    return 0
+  fi
+
+  local rel
+  for rel in graph.json GRAPH_REPORT.md manifest.json .graphify_analysis.json .graphify_labels.json publish-manifest.json cost.json; do
+    if [ ! -e "${source_dir}/${rel}" ]; then
+      continue
+    fi
+    if [ -e "${target_dir}/${rel}" ] || [ -L "${target_dir}/${rel}" ]; then
+      continue
+    fi
+    ln -s "${source_dir}/${rel}" "${target_dir}/${rel}" 2>/dev/null || true
+  done
+
+  echo "[pool] Bound graphify bundle '${CONVEYOR_GRAPHIFY_SLUG}' into ${target_dir}"
+}
+
+mark_git_ready() {
+  bind_graphify_bundle
+  : > "$GIT_READY_MARKER"
+}
+
+configure_graphify_env
+
 # ═══════════════════════════════════════════════════════════════════════════
 # WORKSPACE GIT — moved OFF the pre-launch critical path (Claudespace v3).
 #
@@ -489,7 +578,7 @@ prepare_workspace_git() {
     # Task repo is ready HERE — release the gate. The agent (already launched)
     # is polling for this marker before it spawns Claude / runs setup. Reference
     # repos are cloned AFTER this so they never block Claude.
-    : > "$GIT_READY_MARKER"
+    mark_git_ready
   elif [ -d "repo/.git" ] && [ -n "${CONVEYOR_GITHUB_TOKEN}" ]; then
     # Non-image but repo already present (e.g. a baked image running without
     # CONVEYOR_POD_IMAGE set). Must NOT settle for a bare remote-URL refresh —
@@ -501,7 +590,7 @@ prepare_workspace_git() {
     if ! sync_task_branch_to_repo; then
       return 1
     fi
-    : > "$GIT_READY_MARKER"
+    mark_git_ready
   elif [ -n "${CONVEYOR_GITHUB_TOKEN}" ] && [ -n "${REPO_OWNER}" ] && [ -n "${REPO_NAME}" ] && [ -n "${BRANCH}" ]; then
     echo "[pool] Cloning repo post-assignment (pre-clone was missing)..."
     # Guard each clone/fetch/checkout: under `set -e` a bare failing clone would
@@ -543,14 +632,14 @@ prepare_workspace_git() {
         return 1
       fi
     fi
-    : > "$GIT_READY_MARKER"
+    mark_git_ready
   else
     # No git plan (e.g. task-less pod, or no token/repo). Nothing to prepare —
     # the repo dir already exists (created before launch) and the agent's own
     # git-sync fallback (guarded by CONVEYOR_GIT_READY) never runs on this pod
     # path anyway. Signal ready so the agent doesn't wait out the timeout.
     echo "[pool] No git plan to prepare — marking git ready."
-    : > "$GIT_READY_MARKER"
+    mark_git_ready
   fi
 
   # ── Clone reference repos into /workspaces/references (best-effort) ──