@rallycry/conveyor-agent 10.4.4 → 10.6.0

package/dist/{chunk-VCXKVINO.js → chunk-5FRDOFI4.js}

@@ -197,6 +197,8 @@ var AgentConnection = class _AgentConnection {
   earlyPullBranches = [];
   spawnReviewCallback = null;
   earlySpawnReviews = [];
+  spawnTuiCallback = null;
+  earlySpawnTuis = [];
   // PTY relay (S5 terminal). Single-slot callbacks, set per PtySession run.
   ptyInputCallback = null;
   ptyResizeCallback = null;
@@ -404,6 +406,10 @@ var AgentConnection = class _AgentConnection {
         if (this.spawnReviewCallback) this.spawnReviewCallback(data);
         else this.earlySpawnReviews.push(data);
       });
+      this.socket.on("session:spawnTui", (data) => {
+        if (this.spawnTuiCallback) this.spawnTuiCallback(data);
+        else this.earlySpawnTuis.push(data);
+      });
       this.socket.on("session:finalizeSnapshot", () => {
         this.finalizeSnapshotCallback?.();
       });
@@ -659,6 +665,25 @@ var AgentConnection = class _AgentConnection {
     }).catch(() => {
     });
   }
+  onSpawnTui(callback) {
+    this.spawnTuiCallback = callback;
+    for (const data of this.earlySpawnTuis) callback(data);
+    this.earlySpawnTuis = [];
+  }
+  /**
+   * 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.
+   */
+  reportSessionSpawnFailure(spawnedSessionId, error) {
+    if (!this.socket) return;
+    void this.call("reportSessionSpawnFailure", {
+      sessionId: this.config.sessionId,
+      spawnedSessionId,
+      ...error ? { error: error.slice(0, 2e3) } : {}
+    }).catch(() => {
+    });
+  }
   onFinalizeSnapshot(callback) {
     this.finalizeSnapshotCallback = callback;
   }
@@ -2279,6 +2304,15 @@ var ReportReviewSpawnFailureRequestSchema = z.object({
   reviewSessionId: z.string(),
   error: z.string().max(2e3).optional()
 });
+var SpawnTaskSessionRequestSchema = z.object({
+  taskId: z.string(),
+  kind: z.enum(["tui", "shell"])
+});
+var ReportSessionSpawnFailureRequestSchema = z.object({
+  sessionId: z.string(),
+  spawnedSessionId: z.string(),
+  error: z.string().max(2e3).optional()
+});
 var RefreshGithubTokenResponseSchema = z.object({
   token: z.string()
 });
@@ -2671,12 +2705,6 @@ var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
 var PRE_BUILD_TASK_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
-function hasTaskPlan(plan) {
-  return !!plan?.trim();
-}
-function taskNeedsPlanning(task) {
-  return !hasTaskPlan(task.plan) && PRE_BUILD_TASK_STATUSES.has(task.status) && !task.githubPRUrl;
-}
 
 // src/runner/mode-controller.ts
 var ModeController = class {
@@ -2763,28 +2791,19 @@ var ModeController = class {
     return this._mode;
   }
   /**
-   * An auto task that still NEEDS PLANNING (no plan saved, pre-build status, no
-   * PR — see `taskNeedsPlanning` in @project/shared) runs the read-only plan turn
-   * first (`--permission-mode plan`): resolveInitialMode leaves it in `auto` with
-   * `_hasExitedPlanMode = false`, and once the agent finishes it calls
-   * ExitPlanMode → building. Everything else bypasses planning and builds
-   * immediately with `--dangerously-skip-permissions`:
-   *
-   * - a plan already on the card (e.g. a Planning card planned by a human/PM),
-   * - a build already underway (status past `Planning`/`Open` — releases booted
-   *   `InProgress`, pod restarts mid-build where DB `agentMode` stays `"auto"`),
-   * - a PR already open (safety net if status lags).
-   *
-   * Runtime Build-after-Discovery never reaches this gate as `auto` — the server's
-   * `resolveModeToSend` rewrites it to `"building"` for any task with a plan.
+   * Auto mode always bypasses the plan turn: resolveInitialMode calls
+   * transitionToBuilding() at boot, so the agent runs with
+   * `--dangerously-skip-permissions` from turn 1 and documents its plan into
+   * the card (via update_task_plan) as the approach firms up — non-blocking,
+   * never a gate. Use discovery mode for a plan turn that stops for human
+   * approval. Non-auto modes never bypass.
    */
-  canBypassPlanning(context) {
-    if (this._mode !== "auto") return false;
-    return !taskNeedsPlanning(context);
+  canBypassPlanning(_context) {
+    return this._mode === "auto";
   }
   // ── Mode transitions ───────────────────────────────────────────────
   /** Handle mode change from server */
-  handleModeChange(newMode, context) {
+  handleModeChange(newMode, _context) {
     if (newMode === this._mode) return { type: "noop" };
     if (this._runnerMode === "task" && newMode === "review") {
       this._mode = newMode;
@@ -2799,7 +2818,7 @@ var ModeController = class {
     if (this._runnerMode === "task" && newMode === "auto") {
       this._mode = newMode;
       this._isAuto = true;
-      this._hasExitedPlanMode = !context || !taskNeedsPlanning(context);
+      this._hasExitedPlanMode = true;
       return { type: "restart_query", newMode: "auto" };
     }
     if (this._mode === "auto" && this._hasExitedPlanMode && newMode === "building") {
@@ -5196,6 +5215,7 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     ``,
     `1. Call list_subtasks to see the current state of all child tasks.`,
     `   The response includes PR info, agent assignment, and **dependency info** (dependencies array + allDependenciesMet flag).`,
+    `   If list_subtasks returns NO children, this is a fresh parent card: break the work down now \u2014 explore the codebase, save a parent-level plan with update_task_plan, then create child tasks with create_subtask, each with a detailed plan (file:line citations, verification steps) and dependsOn set for any child that blocks on another. Then fire the ready children and continue the loop.`,
     ``,
     `2. Evaluate children by status and dependency readiness:`,
     `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr. (Highest priority)`,
@@ -5258,6 +5278,7 @@ function buildPackRunnerInstructions(context, scenario) {
     parts.push(
       `You are the Pack Runner for this task and its subtasks.`,
       `Begin your autonomous loop immediately: call list_subtasks to assess the current state.`,
+      `If there are no children yet, create them first \u2014 save a parent-level plan with update_task_plan, then create child tasks with detailed plans and dependsOn set where one blocks on another. Then fire the ready ones.`,
       `If any child is in "ReviewPR" status, review and merge its PR first.`,
       `Then fire the next "Open" child task.`
     );
@@ -5692,15 +5713,15 @@ function buildPmAutoWithPlanRelaunchParts() {
   return [
     `
 You are in auto mode. A plan already exists for this task.`,
-    `Verify that story points, title, and tags are set via get_current_plan, then call ExitPlanMode immediately to transition to building.`,
+    `Begin implementing it now \u2014 refine story points, title, and tags via update_task_properties if they look like placeholders.`,
     `Do NOT wait for team input \u2014 proceed autonomously.`
   ];
 }
 function buildPmAutoPlanningRelaunchParts() {
   return [
     `
-You are in auto mode. Continue planning autonomously.`,
-    `When the plan and all required properties are set, call ExitPlanMode to transition to building.`,
+You are in auto mode. Continue building autonomously.`,
+    `Save a concise plan with update_task_plan as your approach firms up \u2014 never pause or wait for approval.`,
     `Do NOT wait for team input \u2014 proceed autonomously.`
   ];
 }
@@ -5776,6 +5797,20 @@ function buildPropertyInstructions(context, runnerMode) {
   }
   return parts;
 }
+function buildPlanDocumentationSection(context) {
+  const hasPlan = !!context?.plan?.trim();
+  return [
+    ``,
+    `### Plan & Properties (non-blocking \u2014 do NOT pause the build for these)`,
+    `- The card is already In Progress and advances automatically (In Progress \u2192 Review PR when you open the PR). There is no plan-approval step.`,
+    ...hasPlan ? [
+      `- A plan is already saved on the card. Keep it current with update_task_plan if your approach diverges materially from it.`
+    ] : [
+      `- No plan is saved yet: once your approach settles, save a concise implementation plan with update_task_plan (file:line citations). Fill it in as you go \u2014 never wait on it before writing code.`
+    ],
+    `- Identification auto-fills title, story points, and icon with quick AI guesses. After exploring, refine the title and story points with update_task_properties if they look like placeholders. Icons are automatic \u2014 never set them.`
+  ];
+}
 function buildExplorationMethodology() {
   return [
     ``,
@@ -5875,23 +5910,10 @@ function buildAutoPrompt(context, runnerMode) {
   const parts = [
     `
 ## Mode: Auto`,
-    `You are in Auto mode \u2014 operating autonomously through planning \u2192 building \u2192 PR.`,
-    ``,
-    `### Phase 1: Discovery & Planning (current)`,
-    `- You are in the SDK's plan mode \u2014 read-only access is enforced automatically`,
-    `- You have MCP tools for task properties: update_task_plan, update_task_properties`,
-    ``,
-    `### Required before transitioning:`,
-    `Before calling ExitPlanMode, you MUST fill in ALL of these:`,
-    `1. **Plan** \u2014 Save a clear implementation plan using update_task_plan`,
-    `2. **Story Points** \u2014 Assign via update_task_properties`,
-    `3. **Title** \u2014 Set an accurate title via update_task_properties (if the current one is vague or "Untitled")`,
-    ``,
-    `### Transitioning to Building:`,
-    `When your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
-    `- If any required properties are missing, ExitPlanMode will be denied with details on what's missing`,
-    `- Once ExitPlanMode succeeds, you will seamlessly transition to full build access within the same session`,
-    `- Continue directly with implementation \u2014 no restart or waiting is needed`,
+    `You are in Auto mode \u2014 operating autonomously through building \u2192 PR.`,
+    `- You have full coding access (read, write, edit, bash, git) from the start \u2014 there is no read-only planning phase`,
+    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
+    ...buildPlanDocumentationSection(context),
     ``,
     `### Subtask Plan Requirements`,
     `When creating subtasks, each MUST include a detailed \`plan\` field:`,
@@ -5907,8 +5929,8 @@ function buildAutoPrompt(context, runnerMode) {
     ...context?.isParentTask ? [
       ``,
       `### Parent Task Guidance`,
-      `You are a parent task. Your plan should define child tasks with detailed plans, not direct implementation steps.`,
-      `After ExitPlanMode, you'll transition to Review mode to coordinate child task execution.`,
+      `You are a parent task \u2014 coordinate child tasks instead of implementing directly.`,
+      `If no children exist yet, break the work down now: save a parent-level plan with update_task_plan, then create child tasks with create_subtask (each with a detailed plan).`,
       `Child task status lifecycle: Open \u2192 InProgress \u2192 ReviewPR \u2192 ReviewDev \u2192 Complete.`,
       `Set child ordering with \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` \u2014 explicit metadata the pack runner schedules off, not order described in plan text. Independent children get none and run in parallel.`
     ] : [],
@@ -5946,7 +5968,8 @@ function buildModePrompt(agentMode, context, runnerMode) {
           `2. \`bun run test:affected\` \u2014 runs only the tests your diff can affect (docs-only diffs run nothing; apps/api diffs run unit tests only since CI covers the int shards; shared/db diffs escalate to the full suite automatically)`,
           `Docs/markdown/.claude-only changes need NO local gates \u2014 open the PR and let CI validate.`,
           `If a gate fails, fix it before opening the PR. Do NOT open PRs with known failing gates. Never run the full \`bun run test\` for a diff confined to one package.`,
-          `For refactors: also run \`git diff ${context?.baseBranch ?? "dev"}..HEAD\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`
+          `For refactors: also run \`git diff ${context?.baseBranch ?? "dev"}..HEAD\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`,
+          ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
         ]
       ];
       return parts.join("\n");
@@ -6343,16 +6366,15 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
     if (context.plan?.trim()) {
       return [
         `You are operating autonomously. A plan already exists for this task.`,
-        `Verify that story points, title, and tags are set, then call ExitPlanMode immediately to transition to building.`,
-        `Do NOT re-plan or wait for team input \u2014 proceed autonomously.`
+        `Begin implementing it now \u2014 do NOT re-plan or wait for team input.`,
+        `Refine story points, title, and tags via update_task_properties if they look like placeholders.`
       ];
     }
     return [
-      `You are operating autonomously. Begin planning immediately.`,
+      `You are operating autonomously. No plan is saved on this card yet \u2014 start building now.`,
       `1. Search the codebase (grep/glob) to locate relevant files, then read the critical ones`,
-      `2. Draft a clear implementation plan and save it with update_task_plan`,
-      `3. Set story points, tags, and title (update_task_properties)`,
-      `4. When the plan and all required properties are set, call ExitPlanMode to transition to building`,
+      `2. Implement the work; as your approach firms up, save a concise plan with update_task_plan \u2014 never pause or wait for approval`,
+      `3. Refine story points, tags, and title (update_task_properties) if they look like placeholders`,
       `Do NOT wait for team input \u2014 proceed autonomously.`
     ];
   }
@@ -6373,14 +6395,23 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `When you finish planning, save the plan with update_task_plan, post a summary of the plan for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn. A separate task agent will execute the plan after review.`
     ];
   }
-  const parts = [
+  return buildFreshLeafInstructions(context, isAutoMode);
+}
+function buildFreshLeafInstructions(context, isAutoMode) {
+  const parts = context.plan?.trim() ? [
     `Begin executing the task plan above immediately.`,
-    `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
+    `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`
+  ] : [
+    `No plan is saved on this card yet. Investigate the task briefly (search first, read only critical files), then implement.`,
+    `As your approach firms up, save a concise implementation plan with update_task_plan (file:line citations) \u2014 do NOT pause or wait for approval; the card is already In Progress and advances automatically.`,
+    `Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`
+  ];
+  parts.push(
     `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
     `Use post_to_chat to keep the team informed (your turn output is NOT shown in chat \u2014 post_to_chat is the only way they see it): briefly post what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
     `Before opening the PR, verify with \`bun run check\` (lint + typecheck) and \`bun run test:affected\` (tests scoped to your diff \u2014 docs-only changes need no local gates). Fix any failures. Do NOT open a PR with known failing gates. CI runs the full suite on the PR \u2014 never run the full \`bun run test\` for a diff confined to one package.`,
     `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
-  ];
+  );
   if (isAutoMode) {
     parts.push(
       `
@@ -6429,8 +6460,7 @@ Your plan has been approved. Address the feedback above, then begin implementing
     } else if (isAuto) {
       parts2.push(
         `
-You are in auto mode. Address the feedback above \u2014 update the plan accordingly using update_task_plan.`,
-        `When the plan and all required properties are set, call ExitPlanMode to transition to building.`,
+You are in auto mode. Address the feedback above and continue building \u2014 update the saved plan with update_task_plan if the feedback changes your approach.`,
         `Do NOT wait for additional team input \u2014 the messages above ARE the team's input. Proceed autonomously.`
       );
     } else {
@@ -6469,13 +6499,13 @@ function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
     if (context.plan?.trim()) {
       return [
         `You were relaunched in auto mode. A plan already exists for this task.`,
-        `Verify that story points, title, and tags are set, then call ExitPlanMode immediately to transition to building.`,
+        `Begin implementing it now \u2014 refine story points, title, and tags via update_task_properties if they look like placeholders.`,
         `Do NOT wait for instructions or go idle \u2014 you are in auto mode.`
       ];
     }
     return [
-      `You were relaunched in auto mode. Continue planning autonomously.`,
-      `When the plan and all required properties are set, call ExitPlanMode to transition to building.`,
+      `You were relaunched in auto mode. Continue building autonomously.`,
+      `Save a concise plan with update_task_plan as your approach firms up \u2014 never pause or wait for approval.`,
       `Do NOT wait for instructions or go idle \u2014 you are in auto mode.`
     ];
   }
@@ -6515,7 +6545,13 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
   const isCodeReview = mode === "code-review" || !isPm && agentMode === "review";
   if (scenario === "fresh") {
     parts.push(
-      ...buildFreshInstructions(isPm, isCodeReview, agentMode === "auto", context, agentMode)
+      ...buildFreshInstructions(
+        isPm,
+        isCodeReview,
+        agentMode === "auto" || !!isAuto,
+        context,
+        agentMode
+      )
     );
     return parts;
   }
@@ -7389,7 +7425,7 @@ var DEPENDS_ON_DESCRIPTION = "Sibling subtask ids or slugs this subtask blocks o
 function buildUpdateTaskTool(connection) {
   return defineTool(
     "update_task_plan",
-    "Save the finalized plan and/or description to the current task. Use in Plan mode after alignment. For children use update_subtask; for title/tags/PR use update_task_properties.",
+    "Save the plan and/or description to the current task. In auto/building mode, save the plan as your approach firms up \u2014 non-blocking, never pause the build for it. For children use update_subtask; for title/tags/PR use update_task_properties.",
     {
       plan: z9.string().optional().describe("The task plan in markdown"),
       description: z9.string().optional().describe("Updated task description")
@@ -7744,7 +7780,7 @@ ${issueLines}`;
 
 // src/tools/index.ts
 function getTaskModeTools(agentMode, connection) {
-  if (agentMode === "discovery" || agentMode === "auto") {
+  if (agentMode === "discovery" || agentMode === "auto" || agentMode === "building") {
     return [buildUpdateTaskTool(connection)];
   }
   return [];
@@ -7772,7 +7808,7 @@ function buildConveyorTools(connection, config, context, agentMode) {
   const effectiveMode = agentMode ?? context?.agentMode ?? void 0;
   const commonTools = buildCommonTools(connection, config);
   const modeTools = getModeTools(effectiveMode, connection, config, context);
-  const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" ? buildDiscoveryTools(connection) : [];
+  const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" || effectiveMode === "building" ? buildDiscoveryTools(connection) : [];
   const codeReviewTools = effectiveMode === "review" ? buildCodeReviewTools(connection) : [];
   const emergencyTools = [buildForceUpdateTaskStatusTool(connection)];
   return [...commonTools, ...modeTools, ...discoveryTools, ...codeReviewTools, ...emergencyTools];
@@ -8722,9 +8758,10 @@ function buildQueryOptions(host, context) {
     // the same text via `--append-system-prompt`. PTY-only: the SDK harness
     // already receives it through systemPrompt.append.
     ...host.harnessKind === "pty" && systemPromptText ? { appendSystemPrompt: systemPromptText } : {},
-    // Auto mode pre-exit: after the ExitPlanMode hook allows the call, the
-    // CLI's plan dialog still renders — press Enter so the autonomous agent
-    // continues building in the same session (Conveyor validated in the hook).
+    // Auto mode pre-exit (residual sessions only — auto now boots post-exit):
+    // after the ExitPlanMode hook allows the call, the CLI's plan dialog still
+    // renders — press Enter so the autonomous agent continues building in the
+    // same session (Conveyor validated in the hook).
     planDialogAutoAccept: mode === "auto" && !host.hasExitedPlanMode,
     tools: { type: "preset", preset: "claude_code" },
     mcpServers: {
@@ -10595,9 +10632,9 @@ var SessionRunner = class _SessionRunner {
   /** The build-phase nudge (In Progress, no PR). Offers BOTH escape routes so
    *  the agent never just goes idle. */
   static STUCK_PROMPT = "You are in Auto mode, your task is still In Progress, and there is no open pull request. Do ONE of these right now: (1) open a pull request with the create_pull_request tool, OR (2) call post_to_chat to explain exactly where you are stuck and what you need from a human. Do not finish or go idle silently.";
-  /** The planning-phase nudge (still Planning, identification/plan unfinished).
-   *  Same two-escape-route shape, aimed at finishing discovery instead of a PR. */
-  static STUCK_PROMPT_PLANNING = "You are in Auto mode and still in the Planning phase \u2014 identification and/or the plan are not finished. Do ONE of these right now: (1) finish identifying the task (set the story points) and save the plan with the update_task_plan tool, then call ExitPlanMode to begin building, OR (2) call post_to_chat to explain exactly where you are stuck and what you need from a human. Do not finish or go idle silently.";
+  /** The pre-build nudge (still Planning/Open, identification/plan unfinished).
+   *  Same two-escape-route shape, aimed at landing the plan + continuing to build. */
+  static STUCK_PROMPT_PLANNING = "You are in Auto mode and the card is still in a pre-build status \u2014 identification and/or the plan are not finished. Do ONE of these right now: (1) set the story points, save the plan with the update_task_plan tool, and continue implementing, OR (2) call post_to_chat to explain exactly where you are stuck and what you need from a human. Do not finish or go idle silently.";
   /**
    * 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
@@ -10607,11 +10644,12 @@ var SessionRunner = class _SessionRunner {
    *
    * - "pr":       In Progress with no open PR (build finished without shipping).
    * - "planning": still in a pre-build status (Planning/Open) 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.
+   *   (identified + saved plan) — e.g. the server-side InProgress bump failed
+   *   and the agent idled before documenting its plan. An agent that idles
+   *   here would otherwise 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.
    */
   autoStuckKind() {
     if (!this.mode.isAuto || this.stopped) return null;
@@ -11077,6 +11115,7 @@ export {
   DEFAULT_LIFECYCLE_CONFIG,
   Lifecycle,
   cleanTerminalOutput,
+  loadPtySpawn,
   inheritedEnv,
   buildPromptBytes,
   ClaudeTuiAdapter,
@@ -11110,4 +11149,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-VCXKVINO.js.map
+//# sourceMappingURL=chunk-5FRDOFI4.js.map