@rallycry/conveyor-agent 10.13.71 → 11.0.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _project_shared from '@project/shared';
-import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload, WorkspaceDiscoveredPort, AgentQuestion, AgentRunnerStatus } from '@project/shared';
+import { RunnerMode, AgentSessionServiceMethods, AgentMode, PtyChatEventPayload, WorkspaceDiscoveredPort, AgentQuestion, PackExecution, AgentRunnerStatus } from '@project/shared';
 export * from '@project/shared';
 import { ChildProcess } from 'node:child_process';
 
@@ -56,6 +56,31 @@ interface SpawnReviewData {
     prNumber?: number | null;
     checkoutRef?: string | null;
 }
+/**
+ * Server push asking a PLANNER pod to spawn the Builder child: a second
+ * conveyor-agent process bound to a fresh `mode:"build"` WorkspaceSession. The
+ * lifecycle handoff — a human pressing Build, or a Yolomatic plan landing —
+ * without cold-booting a second pod, and without flipping the planner's own
+ * session into a builder in place.
+ *
+ * Same wire discipline as SpawnReviewData: no taskId (the child inherits the
+ * parent's CONVEYOR_TASK_ID and the server derives it from the JWT), and the
+ * runner mode rides the JWT claim rather than this field — `mode` here is what
+ * the supervisor exports as CONVEYOR_MODE for the child process.
+ */
+interface SpawnBuilderData {
+    sessionId: string;
+    sessionJwt: string;
+    /**
+     * Runner mode for the child — `pack` when the card has children, so the
+     * coordinator gets the single-pod pack prompt and toolset. Optional so a pod
+     * running against an older server (which sends none) still boots as `task`.
+     */
+    mode?: "task" | "pack";
+    branch?: string | null;
+    /** The agent whose model/settings/instructions the Builder runs under. */
+    agentName?: string | null;
+}
 /**
  * Server push asking the builder pod to spawn an extra interactive child on
  * this pod: a second Claude TUI (mode "adhoc") or a raw login shell (mode
@@ -98,6 +123,8 @@ declare class AgentConnection {
     private earlyPullBranches;
     private spawnReviewCallback;
     private earlySpawnReviews;
+    private spawnBuilderCallback;
+    private earlySpawnBuilders;
     private spawnTuiCallback;
     private earlySpawnTuis;
     private probeUsageCallback;
@@ -168,6 +195,9 @@ declare class AgentConnection {
         branch: string;
     }) => void): void;
     onSpawnReview(callback: (data: SpawnReviewData) => void): void;
+    /** Mirror of onSpawnReview for the Builder handoff. Drains the early buffer
+     *  so a Build pressed during boot is not lost. */
+    onSpawnBuilder(callback: (data: SpawnBuilderData) => void): void;
     /**
      * 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
@@ -175,6 +205,15 @@ declare class AgentConnection {
      * it; the review session is identified separately.
      */
     reportReviewSpawnFailure(reviewSessionId: string, error?: string): void;
+    /**
+     * Report that this (planner) pod could not spawn the Builder child, so the
+     * server can End the orphaned build session and reopen the card instead of
+     * leaving it InProgress with a Builder tab that never appears.
+     *
+     * sessionId is OUR (planner) session — the task-identity guard runs on it;
+     * the build session is identified separately.
+     */
+    reportBuilderSpawnFailure(buildSessionId: string, error?: string): void;
     /**
      * Report that this pod's git credential is dead and refreshing did not fix
      * it (fire-and-forget).
@@ -412,14 +451,66 @@ declare class ModeController {
     private _pendingModeRestart;
     private _runnerMode;
     private _isAuto;
+    /**
+     * Which planner this is. Only read when `_runnerMode` is `plan`; see
+     * `effectiveMode` for the full reasoning, and `latchPlanFlavor` for why this
+     * latches toward `chat` and never away from it.
+     */
+    private _planFlavor;
     constructor(initialMode: AgentMode, runnerMode?: RunnerMode, isAuto?: boolean);
+    /**
+     * Promote this planner to the chat flavor, once, and never demote it.
+     *
+     * It cannot be a constructor-only assignment, because the constructor usually
+     * has nothing to go on. A GKE pod's bootstrap bundle carries no agentMode, so
+     * `CONVEYOR_AGENT_MODE` is unset and `initialMode` falls back to `"building"`
+     * for EVERY pod — which is the whole reason `applyServerMode` exists. Pinning
+     * the flavor at construction alone would therefore make every chat card in the
+     * cloud a discovery planner and silently re-open the defect this replaced.
+     *
+     * One-way, and both directions matter:
+     *
+     * - Only the literal card mode `chat` promotes. The server reports `chat` only
+     *   for a card whose agentMode IS `chat`, so a discovery card can never be
+     *   talked into the build-capable flavor. The original hazard — `auto` stamped
+     *   onto a plan-less auto card's planner — is untouched, because `auto` is not
+     *   `chat`.
+     * - Nothing demotes. The Build press overwrites `Task.agentMode` to
+     *   `auto`/`building` before the server sees it, so a later stamp would
+     *   otherwise strip a live conversation's prompt and file deliverables
+     *   mid-turn.
+     *
+     * The asymmetry with `auto` is principled rather than convenient: an auto
+     * card's mode and its planner phase legitimately differ, while a chat card's
+     * mode IS what its session is, for the session's whole life.
+     */
+    private latchPlanFlavor;
     get mode(): AgentMode;
     get isAuto(): boolean;
     get hasExitedPlanMode(): boolean;
     set hasExitedPlanMode(val: boolean);
     get pendingModeRestart(): boolean;
     set pendingModeRestart(val: boolean);
-    /** Effective mode accounting for PM/task defaults */
+    /**
+     * Effective mode accounting for PM/task defaults.
+     *
+     * A `plan` runner is pinned to ONE mode for its whole life, whatever the
+     * card's own agentMode later says. That pin is what makes the planner
+     * read-only, non-build-capable, and prompted for planning — all three derive
+     * from here — and it has to be immune to `applyServerMode`, which runs AFTER
+     * boot and would otherwise stamp `auto` onto the planner of a plan-less auto
+     * card, handing it the build prompt and `--dangerously-skip-permissions`
+     * inside a session whose whole purpose is not to have them.
+     *
+     * There are TWO planner flavors, and which one this session is was decided at
+     * boot (`_planFlavor`) — never re-read from the mutable `_mode`. A chat card
+     * boots a plan session too (it is a Planner-session flavor, not a builder in
+     * disguise), and it must keep `buildChatPrompt`, its file deliverables, and
+     * the build-capable tool handler. Reading the flavor from `_mode` would put
+     * that choice back under server control and re-open the exact hole the
+     * paragraph above closes, in the other direction: a stamp of `chat` onto a
+     * discovery planner would hand it build capability.
+     */
     get effectiveMode(): AgentMode;
     get isReadOnly(): boolean;
     get isAutoPlanning(): boolean;
@@ -507,7 +598,13 @@ declare class Lifecycle {
     stopGitFlush(): void;
     startUsageSample(): void;
     stopUsageSample(): void;
-    startIdleTimer(): void;
+    /** Start (or restart) the idle timer.
+     *  @param overrideMs Optional custom delay in ms, mirroring
+     *  `startDormantTimer`. SessionRunner passes a short delay when it DEFERS a
+     *  shutdown because a spawned child is still working: the pod must re-check
+     *  soon after that child exits, rather than granting itself a fresh full idle
+     *  window every time it defers. */
+    startIdleTimer(overrideMs?: number): void;
     cancelIdleTimer(): void;
     /** Start (or restart) the dormant timer.
      *  @param overrideMs Optional custom delay in ms. When provided, the timer
@@ -522,10 +619,43 @@ declare class Lifecycle {
     private clearIdleTimers;
 }
 
+/**
+ * Who else is working on this pod?
+ *
+ * The Planner is the pod's MAIN process, so its idle/dormant timeouts end the
+ * whole pod: `stopped = true` → `shutdown("finished")` → `process.exit(0)` →
+ * the supervisor logs "agent exited cleanly, shutting down pod". Nothing used
+ * to ask whether a spawned child was still working. A handed-off build that
+ * outlived the Planner's idle window therefore died mid-run — the work survived
+ * only as far as the last `conveyor-wip` flush, the janitor parked the
+ * workspace, and the card reverted to Open.
+ *
+ * This is the seam that lets `SessionRunner` ask without importing the
+ * supervisors: `cli.ts` owns them and hands the runner a probe. Keeping the
+ * dependency pointing that way also keeps the runner testable with a fake.
+ *
+ * Ordering is deliberate — `builder` first — so the deferral log names the
+ * session a human is most likely looking for when they ask why a pod is still
+ * up.
+ */
+/** A child supervisor, reduced to the one question the shutdown path asks. */
+interface ChildSessionSource {
+    /**
+     * Names the child kind in the deferral log. `tui` rather than `session` —
+     * these come from `session:spawnTui`, but "session session <id>" stutters in
+     * the one place this string is read.
+     */
+    readonly kind: "builder" | "review" | "tui";
+    /** Sessions this supervisor currently hosts. Empty when it hosts none. */
+    activeSessionIds(): string[];
+}
+
 interface SessionRunnerConfig {
     connection: AgentConnectionConfig;
     agentMode?: AgentMode;
     runnerMode?: RunnerMode;
+    /** Only read when `runnerMode` is "pack". Defaults to single-pod. */
+    packExecution?: PackExecution;
     isAuto?: boolean;
     workspaceDir: string;
     model?: string;
@@ -601,6 +731,33 @@ declare class SessionRunner {
     private agentLiveReported;
     constructor(config: SessionRunnerConfig, callbacks: SessionRunnerCallbacks, deps?: SessionRunnerDependencies);
     get state(): AgentRunnerStatus;
+    /**
+     * Supervisors whose live children keep this pod alive. Empty until `cli.ts`
+     * wires them, which is deliberate: the supervisors are constructed AFTER the
+     * runner, and an empty list simply means "no children to protect" — the
+     * pre-existing shutdown behavior.
+     */
+    private liveChildSources;
+    /** Called by `cli.ts` once the child supervisors exist. */
+    setLiveChildSources(sources: readonly ChildSessionSource[]): void;
+    /**
+     * Suppress an idle/dormant shutdown while a spawned child is still working.
+     *
+     * The Planner is the pod's main process, so its timeouts take the pod — and
+     * the Builder's in-flight work — down with it. Returns true when the shutdown
+     * was deferred and the caller must not proceed.
+     *
+     * Re-arms with a SHORT delay rather than a fresh full window: the pod should
+     * converge on shutdown soon after the last child exits, not one more idle
+     * window later. Bounded by the configured timeout so a test with a 50ms idle
+     * window re-checks in 50ms rather than a minute.
+     *
+     * Fail-open by construction — if the probe throws, or no sources are wired,
+     * the shutdown proceeds exactly as before. The opposite bias (a pod that
+     * cannot die) is the more expensive mistake here only in money; killing a
+     * live build costs work.
+     */
+    private deferShutdownForLiveChild;
     get sessionId(): string;
     get isStopped(): boolean;
     /** Wire the boot supervisor handle post-construction — cli.ts constructs it
@@ -815,6 +972,16 @@ interface AgentRunnerConfig {
     mode?: _project_shared.RunnerMode;
     isAuto?: boolean;
     agentSettings?: _project_shared.AgentSettings;
+    /**
+     * How a `mode: "pack"` session executes its children.
+     *
+     * "single-pod" (the default): this session implements every child itself,
+     * serially. "fan-out": the legacy coordinator — it fires one pod per child
+     * and writes no code. Carried as a sub-flag rather than a new `RunnerMode`
+     * so `resolveModeEnv`, the JWT mode claim, and every `mode === "pack"`
+     * reader keep working unchanged.
+     */
+    packExecution?: _project_shared.PackExecution;
 }
 interface AgentRunnerCallbacks {
     onEvent: (event: Record<string, unknown>) => void | Promise<void>;

package/dist/index.js

@@ -1,7 +1,11 @@
+import {
+  SessionRunner,
+  unshallowRepo
+} from "./chunk-PEEGCZAR.js";
+import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,
   GIT_TIMEOUT_MS,
-  SessionRunner,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
@@ -10,11 +14,10 @@ import {
   loadForwardPorts,
   pushToOrigin,
   stageAndCommit,
-  unshallowRepo,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-7MMECTTJ.js";
-import "./chunk-QU53HND5.js";
+} from "./chunk-N4WSUTGV.js";
+import "./chunk-GL2DIQEQ.js";
 import "./chunk-IA45XHOA.js";
 import {
   getWorkbenchClient
@@ -22,11 +25,12 @@ import {
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
+import "./chunk-3F4ZZKCA.js";
 import {
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand
-} from "./chunk-GJXAAPJ6.js";
+} from "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/runner/worktree.ts

package/dist/serve-boot-YPAUKENG.js

@@ -0,0 +1,225 @@
+import {
+  WorkspaceCommandSupervisor
+} from "./chunk-JQVAWRVL.js";
+import {
+  AgentConnection,
+  CodespacePortVisibility,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  PortDiscovery,
+  awaitGitReady,
+  createServiceLogger,
+  ensureOnTaskBranch,
+  loadConveyorConfig
+} from "./chunk-N4WSUTGV.js";
+import "./chunk-GL2DIQEQ.js";
+import "./chunk-IA45XHOA.js";
+import "./chunk-EXQ6AHOY.js";
+import "./chunk-KMB3BU4S.js";
+import "./chunk-W4LZ7R6Z.js";
+import "./chunk-6Q6LQBWO.js";
+
+// src/runner/serve-session-runner.ts
+var ServeSessionRunner = class {
+  connection;
+  lifecycle;
+  config;
+  callbacks;
+  portDiscovery;
+  commandSupervisor;
+  git;
+  stopped = false;
+  stopResolver = null;
+  _finalState = null;
+  constructor(config, callbacks = {}, deps) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.connection = deps?.connection ?? new AgentConnection(config.connection);
+    const portVisibility = new CodespacePortVisibility();
+    this.portDiscovery = deps?.portDiscovery ?? new PortDiscovery({
+      report: (ports) => this.connection.reportDiscoveredPorts(ports),
+      onReported: (ports) => portVisibility.ensureVisible(ports.map(({ port }) => port))
+    });
+    this.commandSupervisor = deps?.commandSupervisor ?? new WorkspaceCommandSupervisor({
+      config: loadConveyorConfig(),
+      workspaceDir: config.workspaceDir,
+      connection: this.connection
+    });
+    this.git = deps?.git ?? {
+      awaitGitReady: (opts) => awaitGitReady(opts),
+      checkoutBranch: (cwd, branch) => ensureOnTaskBranch(cwd, branch)
+    };
+    this.lifecycle = new Lifecycle(
+      // No git flush and no usage sample: nothing here writes to the checkout,
+      // and the serving bundle selects no coding-agent key to measure.
+      {
+        ...DEFAULT_LIFECYCLE_CONFIG,
+        gitFlushIntervalMs: 0,
+        usageSampleIntervalMs: 0,
+        ...config.lifecycle
+      },
+      {
+        onHeartbeat: () => this.connection.sendHeartbeat(),
+        // Never armed (see the file header) — supplied because Lifecycle
+        // requires the full callback set.
+        onIdleTimeout: () => this.requestStop(),
+        onDormantTimeout: () => this.requestStop(),
+        onTokenRefresh: () => void this.connection.refreshTaskTokenFromBootstrap().catch(() => {
+        }),
+        onGitFlush: () => {
+        },
+        onUsageSample: () => {
+        }
+      }
+    );
+  }
+  get finalState() {
+    return this._finalState;
+  }
+  get isStopped() {
+    return this.stopped;
+  }
+  /** Connect, register the session, launch the start command, then hold open. */
+  async run() {
+    try {
+      await this.connection.connect();
+      this.connection.sendEvent({
+        type: "connected",
+        sessionId: this.config.connection.sessionId
+      });
+      this.connection.onStop(() => this.requestStop());
+      this.lifecycle.startHeartbeat();
+      this.lifecycle.startTokenRefresh();
+      await this.connection.call("connectAgent", {
+        sessionId: this.config.connection.sessionId
+      });
+      await this.portDiscovery.start().catch(() => {
+      });
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      const gitState = await this.git.awaitGitReady({
+        onLog: (m) => process.stderr.write(`[conveyor-agent] ${m}
+`)
+      });
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      if (gitState === "failed" || gitState === "timeout") {
+        throw new Error(
+          gitState === "failed" ? "Workspace git preparation failed (see pod logs)" : "Workspace git preparation timed out (see pod logs)"
+        );
+      }
+      const onBranch = await this.git.checkoutBranch(this.config.workspaceDir, this.config.branch);
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      if (!onBranch) {
+        throw new Error(
+          `Task-branch checkout failed for "${this.config.branch}"; refusing to serve base-branch code`
+        );
+      }
+      this.commandSupervisor.start();
+      this.commandSupervisor.notifyLoopReady?.();
+      await this.connection.emitStatus("idle");
+      this.callbacks.onEvent?.({ type: "serve_runner_started", taskId: this.config.taskId });
+      await this.waitUntilStopped();
+      this._finalState = "finished";
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[conveyor-agent] Serve runner failed: ${message}
+`);
+      this.connection.sendEvent({ type: "error", message });
+      this._finalState = "error";
+    } finally {
+      await this.shutdown();
+    }
+  }
+  /** External stop (SIGTERM/SIGINT or server session:stop). */
+  stop() {
+    this.requestStop();
+  }
+  requestStop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.portDiscovery.stop();
+    if (this.stopResolver) {
+      const resolve = this.stopResolver;
+      this.stopResolver = null;
+      resolve();
+    }
+  }
+  waitUntilStopped() {
+    if (this.stopped) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.stopResolver = resolve;
+    });
+  }
+  async shutdown() {
+    this.stopped = true;
+    this.portDiscovery.stop();
+    this.lifecycle.destroy();
+    await this.commandSupervisor.stop().catch(() => {
+    });
+    this.connection.sendEvent({ type: "shutdown", reason: this._finalState ?? "finished" });
+    this.connection.disconnect();
+  }
+};
+
+// src/runner/serve-boot.ts
+var logger = createServiceLogger("ServeBoot");
+function outcomeFor(runner) {
+  const errored = runner.finalState === "error";
+  return {
+    exitCode: errored ? 1 : 0,
+    reason: errored ? "error" : "clean",
+    finalState: runner.finalState ?? void 0
+  };
+}
+async function runServingSession(params) {
+  if (!params.sessionId) {
+    logger.error("Serving mode requires CONVEYOR_SESSION_ID");
+    return { exitCode: 1, reason: "error", finalState: "error" };
+  }
+  if (!params.branch) {
+    logger.error("Serving mode requires BRANCH (the card's branch to serve)");
+    return { exitCode: 1, reason: "error", finalState: "error" };
+  }
+  logger.info("Starting preview-only serving runner", {
+    taskId: params.taskId,
+    sessionId: params.sessionId,
+    branch: params.branch
+  });
+  const runner = new ServeSessionRunner(
+    {
+      connection: {
+        apiUrl: params.apiUrl,
+        taskToken: params.taskToken,
+        sessionId: params.sessionId,
+        runnerMode: "serving"
+      },
+      taskId: params.taskId,
+      workspaceDir: params.workspaceDir,
+      branch: params.branch
+    },
+    {
+      onEvent: (event) => {
+        logger.info("Serve runner event", { eventType: event.type });
+      }
+    }
+  );
+  const stop = () => {
+    params.onSignal?.();
+    runner.stop();
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  await runner.run();
+  return outcomeFor(runner);
+}
+export {
+  runServingSession
+};

package/dist/{server-CC7KUJOK.js → server-7XH7RYUX.js}

@@ -1,7 +1,8 @@
 import {
   startWorkbenchServer
-} from "./chunk-DOB2XE2I.js";
-import "./chunk-GJXAAPJ6.js";
+} from "./chunk-UBDSLM44.js";
+import "./chunk-3F4ZZKCA.js";
+import "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 import "./chunk-6W6UZ4SJ.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "10.13.71",
+  "version": "11.0.0",
   "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",
@@ -15,7 +15,8 @@
   },
   "files": [
     "dist",
-    "runtime"
+    "runtime",
+    "skills"
   ],
   "type": "module",
   "main": "./dist/index.js",
@@ -36,8 +37,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.219",
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.246",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "node-pty": "^1.0.0",
     "socket.io-client": "^4.8.3",
     "tar": "^7.5.21",