@rallycry/conveyor-agent 10.13.12 → 10.13.13

package/dist/{chunk-4KIPA6LF.js → chunk-TB5SQIGX.js}

@@ -2662,6 +2662,13 @@ var StartAdhocSessionRequestSchema = z4.object({
   mode: z4.enum(["adhoc", "pm"]).optional(),
   /** Base branch to check out (defaults to the project's dev branch). */
   branch: z4.string().max(300).optional(),
+  /**
+   * Server-assembled instructions the pod's TUI auto-submits once on first boot
+   * (headless kickoff). Used by the onboarding "Set it up for me" flow to seed a
+   * setup-driver prompt; the session stays watchable/interactive in the Sessions
+   * view. `ensureAdhocWorkspace` persists it and clears it after first submit.
+   */
+  initialPrompt: z4.string().max(2e4).optional(),
   requestingUserId: z4.string().optional()
 });
 var StopAdhocSessionRequestSchema = z4.object({
@@ -4465,6 +4472,22 @@ async function readRaw(path3) {
     return null;
   }
 }
+function classifyTuiAuth(input) {
+  if (!input.isCloud) return "ready";
+  if (input.hasOauthToken || input.hasApiKey || input.credsHasAccessToken) return "ready";
+  return "no-credential";
+}
+async function resolveTuiAuthReadiness(env = process.env, readIdentity = readCredentialsIdentity) {
+  const isCloud = isConveyorCloudEnv(env);
+  const credsHasAccessToken = isCloud ? Boolean((await readIdentity())?.accessToken) : false;
+  const status = classifyTuiAuth({
+    isCloud,
+    hasOauthToken: Boolean(env.CLAUDE_CODE_OAUTH_TOKEN),
+    hasApiKey: Boolean(env.ANTHROPIC_API_KEY),
+    credsHasAccessToken
+  });
+  return { ready: status === "ready", status };
+}
 async function readCredentialsIdentity() {
   const parsed = parseClaudeAiOauth(await readRaw(claudeCredentialsPath()));
   if (!parsed) return null;
@@ -5149,6 +5172,39 @@ var PtySession = class {
   writeStdin(text) {
     this.pty?.write(text);
   }
+  /**
+   * Inject a follow-up message into the CURRENTLY-RUNNING turn by pasting it into
+   * the live TUI input, exactly as a human typing mid-turn would — the CLI queues
+   * it and picks it up at the next turn boundary. Unlike beginTurn this does NOT
+   * reset per-turn state, allocate a new queue, or re-arm the abort listener: the
+   * in-flight turn (and its transcript stream) keeps flowing, so the injected
+   * message and its response ride the SAME event pipeline. Returns false when
+   * there is no live, actively-draining turn to inject into — parked/idle
+   * (activeQueue === null), torn down, exited, or a raw-terminal TUI that gives
+   * us no trusted signal that a turn is running — so the caller falls back to the
+   * abort+respawn supersede path.
+   */
+  injectIntoRunningTurn(text) {
+    if (!this.pty || this._toreDown || this.exited) return false;
+    if (this.activeQueue === null) return false;
+    if (!this.adapter.capabilities.structuredEvents) return false;
+    if (!text.trim()) return false;
+    void this.submitLivePrompt(text);
+    return true;
+  }
+  /**
+   * Paste + submit a prompt into the live pty WITHOUT any turn bookkeeping.
+   * Mirrors deliverPrompt's submit path (bracketed paste, then a separate Enter
+   * after a settle window) but never arms the submit nudge — the running turn is
+   * already producing transcript records, so re-pressing Enter would risk
+   * accepting an unrelated mid-turn dialog. Fire-and-forget.
+   */
+  async submitLivePrompt(text) {
+    this.writeStdin(this.adapter.encodePromptBytes(text));
+    await sleep(resolveSubmitSettleMs());
+    if (this._toreDown || this.exited) return;
+    this.writeStdin("\r");
+  }
   /** Apply a relayed resize to the live pty (reconciled dims from the server). */
   resizePty(cols, rows) {
     if (cols <= 0 || rows <= 0) return;
@@ -5560,6 +5616,9 @@ var PtyHarness = class _PtyHarness {
   endedTimer = null;
   /** Passive-activity subscriber, re-attached to whichever session is parked. */
   passiveHandler = null;
+  /** Once-per-session guard so the "no Claude credential" notice isn't re-posted
+   *  on every respawn (a fresh spawn happens on each fingerprint/lineage flip). */
+  authNoticeSent = false;
   /**
    * Wiggle the live pty's size so the CLI repaints its whole screen. No-op on
    * the SDK harness. Falls back to the parked session so an API reconnect while
@@ -5568,6 +5627,30 @@ var PtyHarness = class _PtyHarness {
   forceRepaint() {
     (this.activeSession ?? this.parked)?.forceRepaint();
   }
+  /** Actionable message posted to the card when a spawn will park at the Claude
+   *  sign-in screen. Kept as a constant so the harness stays free of i18n deps. */
+  static AUTH_NOT_READY_MESSAGE = "\u26A0\uFE0F This pod started the Claude Code TUI with no Claude credential, so it is parked on the sign-in screen and can't make progress. This usually means there is no usable Claude subscription token or API key configured for this project/assignee. Add or repair the Claude credential in project settings, then restart the session.";
+  /**
+   * Best-effort: if the TUI is about to spawn with no usable credential, post a
+   * one-time diagnostic through the relay bridge. Never throws — a readiness
+   * probe must not block or fail a spawn.
+   */
+  async warnIfAuthNotReady() {
+    if (this.authNoticeSent || !this.bridge?.notifyAuthNotReady) return;
+    try {
+      const readiness = await resolveTuiAuthReadiness();
+      if (readiness.ready) return;
+      this.authNoticeSent = true;
+      this.bridge.notifyAuthNotReady(_PtyHarness.AUTH_NOT_READY_MESSAGE);
+      _PtyHarness.log.warn(
+        "Claude TUI spawning with no usable credential \u2014 parked at sign-in screen"
+      );
+    } catch (err) {
+      _PtyHarness.log.warn("auth-readiness probe failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   async *executeQuery(opts) {
     const want = opts.resume ?? opts.options.resume;
     const fingerprint = this.fingerprintOf(opts.options);
@@ -5589,6 +5672,9 @@ var PtyHarness = class _PtyHarness {
         await ensureUsableClaudeConfigHome(opts.options.cwd, _PtyHarness.log);
       }
       await this.adapter.prepareEnvironment({ cwd: opts.options.cwd });
+      if (this.adapter.capabilities.structuredEvents) {
+        await this.warnIfAuthNotReady();
+      }
       session.onExit(() => this.handleSessionExit(session));
       await session.start();
     }
@@ -5599,6 +5685,15 @@ var PtyHarness = class _PtyHarness {
    * query running" (a human typed into the idle Connected-TUI). Attaches to the
    * currently-parked session and to any session parked later.
    */
+  /**
+   * PTY-only: inject a follow-up message into the turn currently streaming
+   * events (the active session), so the runner can add to a running turn without
+   * aborting + respawning. Returns false when no turn is active (idle/parked) or
+   * the paste couldn't be delivered — the caller supersedes instead.
+   */
+  injectIntoRunningTurn(text) {
+    return this.activeSession?.injectIntoRunningTurn(text) ?? false;
+  }
   onPassiveActivity(handler) {
     this.passiveHandler = handler;
     const unsubParked = this.parked?.onPassiveActivity(handler);
@@ -6378,6 +6473,18 @@ function buildPlanDocumentationSection(context) {
     `- 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 buildNoPrWhenNoCodeSection(baseBranch) {
+  const base = baseBranch ?? "dev";
+  return [
+    ``,
+    `### A PR is NOT required \u2014 only open one for actual code changes`,
+    `\`create_pull_request\` is for tasks that change code in the repo. Many tasks don't: support requests, config/credential help, answering a question, investigations, or research whose deliverable is an answer or a file rather than a diff.`,
+    `- If you finish the work with NO code changes (an empty \`git diff ${base}..HEAD\`), do NOT open a PR. An empty or throwaway PR just to "complete" the workflow is wrong \u2014 a human then has to close it.`,
+    `- Deliver the result where it belongs: post the answer/config/findings with \`post_to_chat\`, and attach any files the user should keep with \`upload_attachment\`.`,
+    `- Then complete the card directly with \`force_update_task_status("Complete")\` \u2014 there is no PR or review step for a no-code task.`,
+    `- When in doubt, check \`git diff ${base}..HEAD\`: a real diff means open a PR; no diff means finish in chat and mark Complete.`
+  ];
+}
 function buildExplorationMethodology() {
   return [
     ``,
@@ -6500,7 +6607,7 @@ function buildAutoPrompt(context, runnerMode) {
       `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.`
-    ] : [],
+    ] : buildNoPrWhenNoCodeSection(context?.baseBranch),
     ``,
     `### Autonomous Guidelines:`,
     `- Make decisions independently \u2014 do not ask the team for approval at each step`,
@@ -6510,37 +6617,40 @@ function buildAutoPrompt(context, runnerMode) {
   if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
   return parts.join("\n");
 }
+function buildBuildingPrompt(context) {
+  const parts = [
+    `
+## Mode: Building`,
+    `You are in Building mode \u2014 executing the plan.`,
+    `- You have full coding access (read, write, edit, bash, git)`,
+    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
+    ...context?.isParentTask ? [
+      `- You are a parent task. Use \`list_subtasks\`, \`start_child_cloud_build\`, and subtask management tools to coordinate children.`,
+      `- Do NOT implement code directly \u2014 fire child builds and review their work.`,
+      `- Goal: coordinate child task execution and ensure all children complete successfully`
+    ] : [
+      `- If this is a leaf task (no children): execute the plan directly`,
+      `- Goal: implement the plan, run scoped verification, open a PR when done`,
+      ``,
+      `### Pre-PR Verification Checklist`,
+      `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Before calling \`mcp__conveyor__create_pull_request\`, scope verification to your diff:`,
+      `1. \`bun run check\` \u2014 lint + typecheck (fast; run whenever you changed code)`,
+      `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.`,
+      ...buildNoPrWhenNoCodeSection(context?.baseBranch),
+      ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
+    ]
+  ];
+  return parts.join("\n");
+}
 function buildModePrompt(agentMode, context, runnerMode) {
   switch (agentMode) {
     case "discovery":
       return buildDiscoveryPrompt(context, runnerMode);
-    case "building": {
-      const parts = [
-        `
-## Mode: Building`,
-        `You are in Building mode \u2014 executing the plan.`,
-        `- You have full coding access (read, write, edit, bash, git)`,
-        `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
-        ...context?.isParentTask ? [
-          `- You are a parent task. Use \`list_subtasks\`, \`start_child_cloud_build\`, and subtask management tools to coordinate children.`,
-          `- Do NOT implement code directly \u2014 fire child builds and review their work.`,
-          `- Goal: coordinate child task execution and ensure all children complete successfully`
-        ] : [
-          `- If this is a leaf task (no children): execute the plan directly`,
-          `- Goal: implement the plan, run scoped verification, open a PR when done`,
-          ``,
-          `### Pre-PR Verification Checklist`,
-          `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Before calling \`mcp__conveyor__create_pull_request\`, scope verification to your diff:`,
-          `1. \`bun run check\` \u2014 lint + typecheck (fast; run whenever you changed code)`,
-          `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.`,
-          ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
-        ]
-      ];
-      return parts.join("\n");
-    }
+    case "building":
+      return buildBuildingPrompt(context);
     case "review":
       return buildReviewPrompt(context);
     case "auto":
@@ -10002,6 +10112,7 @@ function buildPtyBridge(connection) {
     sendOutput: (data, dims) => connection.sendPtyOutput(data, dims),
     sendChatEvent: (event) => connection.sendPtyChatEvent(event),
     sendEnded: () => connection.sendPtyEnded(),
+    notifyAuthNotReady: (detail) => connection.postChatMessage(detail),
     onInput: (handler) => connection.onPtyInput(handler),
     onResize: (handler) => connection.onPtyResize(handler)
   };
@@ -10072,6 +10183,16 @@ var QueryBridge = class {
   resume() {
     this._stopped = false;
   }
+  /**
+   * Inject a follow-up message into the turn currently running under the harness
+   * (PTY keep-alive) instead of aborting it. Returns true when the harness fed
+   * the message into the live TUI; false when there is no running turn to inject
+   * into or the harness has no live terminal (SDK) — the caller then supersedes
+   * via stop() + respawn.
+   */
+  injectIntoRunningTurn(content) {
+    return this.harness.injectIntoRunningTurn?.(content) ?? false;
+  }
   /**
    * Tear down any parked/active CLI process the harness is keeping alive between
    * turns (PTY keep-alive). Called by SessionRunner on stop/shutdown so the
@@ -11427,12 +11548,35 @@ var SessionRunner = class _SessionRunner {
       const resolve = this.inputResolver;
       this.inputResolver = null;
       resolve(msg);
-    } else {
-      this.pendingMessages.push(msg);
-      if (this._state === "running" || this._state === "waiting_for_input") {
-        this.queryBridge?.stop();
-      }
+      return;
     }
+    if (this._state === "running" && this.canInjectIntoRunningTurn(msg) && this.queryBridge?.injectIntoRunningTurn(msg.content)) {
+      void this.callbacks.onEvent({
+        type: "user_message",
+        content: msg.content,
+        userId: msg.userId
+      });
+      return;
+    }
+    this.pendingMessages.push(msg);
+    if (this._state === "running" || this._state === "waiting_for_input") {
+      this.queryBridge?.stop();
+    }
+  }
+  /**
+   * Whether a mid-turn message may be pasted into the live running TUI rather
+   * than superseding the turn. Restricted to genuine same-mode user follow-ups:
+   * a pending mode restart, an empty body, a prefill hint, or any non-"user"
+   * source (mode_change / pty_passive / system / ci_failure / review_trigger)
+   * must take the abort+respawn path — a mode/fingerprint change needs a fresh
+   * spawn, and a prefill must park unsubmitted for the human.
+   */
+  canInjectIntoRunningTurn(msg) {
+    if (this.mode.pendingModeRestart) return false;
+    if (!msg.content.trim()) return false;
+    if (msg.delivery === "prefill") return false;
+    if (msg.source && msg.source !== "user") return false;
+    return true;
   }
   // ── Query execution with abort handling ────────────────────────────
   /** Run queryBridge.execute, swallowing abort errors from stop/softStop. */
@@ -11950,4 +12094,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-4KIPA6LF.js.map
+//# sourceMappingURL=chunk-TB5SQIGX.js.map