@sideboard-ai/core 0.1.318 → 0.1.319

package/dist/{chunk-23ZUL2EX.js → chunk-U2N32EA6.js}

@@ -2989,7 +2989,7 @@ async function createThread(input, _onSetupLine) {
   let sourceIsFork = false;
   if (!input.cowboy && sourceType === "branch" && (!sourceRef || sourceRef === "HEAD" || sourceRef === "default")) {
     if (isAbleTimeConnected() && getIssueSource() === "abletime") {
-      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-KWOBUL46.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-DVYO4IVS.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -5710,6 +5710,36 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
   };
 }
 
+// src/composer/agent-has-replied.ts
+function joinSteerPrompt(base, addition) {
+  const next = addition.trim();
+  if (!next) return base;
+  const head = base.replace(/\s+$/, "");
+  if (!head) return next;
+  return `${head}
+${next}`;
+}
+function trailingUnansweredUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.origin === "continue" || message.role === "summary") continue;
+    if (message.role === "agent") {
+      const text3 = (message.text ?? "").trim();
+      if (text3 || (message.parts?.length ?? 0) > 0) return null;
+      continue;
+    }
+    if (message.role === "user") return message.text;
+  }
+  return null;
+}
+function livePartsShowAgentReply(parts) {
+  for (const part of parts) {
+    if (part.type === "tool") return true;
+    if ((part.type === "text" || part.type === "thinking") && part.text.trim()) return true;
+  }
+  return false;
+}
+
 // src/composer/consume-attachments.ts
 function consumeComposerAttachments(thread) {
   return {
@@ -5762,6 +5792,128 @@ function shiftQueuedItem(queue, queueAttachments) {
   };
 }
 
+// src/orchestrator/enqueue-thread-send.ts
+function resolveSendFollowUp(thread, requested) {
+  if (requested === "steer" || requested === "queue") return requested;
+  return isOrchestratorThread(thread) ? followUpBehavior() : "queue";
+}
+function rewriteTrailingUserPrompt(threadId, from, to) {
+  if (from === to) return;
+  const thread = readThread(threadId);
+  if (!thread) return;
+  const messages = thread.messages.slice();
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.origin === "continue" || message.role === "summary") continue;
+    if (message.role === "user" && message.text === from) {
+      messages[i] = { ...message, text: to };
+      updateThread(threadId, { messages });
+    }
+    return;
+  }
+}
+function reuseJoinedUserBubble(reused, threadId, last, promptText) {
+  return reused.delete(threadId) && last?.role === "user" && last.origin !== "continue" && last.text === promptText;
+}
+function promptForJoinedSteer(input) {
+  if (input.latestPrompt === input.promptText) return input.agentPrompt;
+  rewriteTrailingUserPrompt(input.threadId, input.promptText, input.latestPrompt);
+  const { agentPrompt: expandedLatest } = expandComposerPrompt(
+    input.worktreePath,
+    expandCanonicalGitRequest(input.latestPrompt),
+    { attachments: input.attachments }
+  );
+  return input.expandedPrompt && input.agentPrompt.endsWith(input.expandedPrompt) ? input.agentPrompt.slice(0, -input.expandedPrompt.length) + expandedLatest : `${input.agentPrompt}
+
+${expandedLatest}`;
+}
+function clearSendBookkeeping(host, threadId) {
+  host.crashContinued.delete(threadId);
+  host.jobContinueCount.delete(threadId);
+  host.jobContinueNudged.delete(threadId);
+  host.haltDrain.delete(threadId);
+}
+async function enqueueThreadSend(host, threadRef, prompt, opts) {
+  const thread = host.requireThread(threadRef);
+  if (thread.status === "archived") {
+    throw new Error(`Thread is archived: ${thread.id}`);
+  }
+  let shouldSteer = false;
+  const sent = await withThreadLock(thread.id, async () => {
+    const current = host.requireThread(thread.id);
+    if (current.status === "archived") {
+      throw new Error(`Thread is archived: ${thread.id}`);
+    }
+    const followUp = resolveSendFollowUp(current, opts?.followUp);
+    const explicit = opts?.attachments;
+    const consumed = explicit !== void 0 ? { attachments: current.attachments, consumed: explicit } : consumeComposerAttachments(current);
+    const inFlightEarly = host.activeTurns.has(thread.id) || host.startingTurns.has(thread.id) || current.status === "running";
+    const agentHasRepliedEarly = livePartsShowAgentReply(readTurnLiveParts(current.id));
+    const draft = host.openSteerPrompt.get(current.id);
+    const queuedHead = !inFlightEarly && current.status === "queued" && current.queue.length > 0 ? current.queue[0] : null;
+    const unanswered = followUp === "steer" && !agentHasRepliedEarly ? draft?.text ?? (inFlightEarly ? trailingUnansweredUserText(current.messages) : queuedHead) : null;
+    if (unanswered != null && (draft ? !draft.spawned : queuedHead != null)) {
+      clearSendBookkeeping(host, thread.id);
+      const combined = joinSteerPrompt(unanswered, prompt);
+      if (draft && !draft.spawned) {
+        draft.text = combined;
+        rewriteTrailingUserPrompt(current.id, unanswered, combined);
+      } else {
+        const queue = current.queue.slice();
+        queue[0] = combined;
+        const queueAttachments = alignQueueAttachments(queue.length, current.queueAttachments);
+        if (consumed.consumed.length > 0) {
+          queueAttachments[0] = [...queueAttachments[0] ?? [], ...consumed.consumed];
+        }
+        const patch2 = { queue, queueAttachments };
+        if (explicit === void 0 && consumed.consumed.length > 0) {
+          patch2.attachments = consumed.attachments;
+        }
+        updateThread(current.id, patch2);
+        host.emit({ type: "queue_changed", threadId: current.id, queue });
+      }
+      if (thisProcessShouldDrainAgentQueues() && !inFlightEarly) {
+        host.armDrain(current.id);
+      }
+      return host.requireThread(current.id);
+    }
+    const promptToQueue = unanswered != null ? joinSteerPrompt(unanswered, prompt) : prompt;
+    if (unanswered != null) {
+      if (draft) draft.text = promptToQueue;
+      rewriteTrailingUserPrompt(current.id, unanswered, promptToQueue);
+      host.reusedUserPrompt.add(current.id);
+    }
+    const queued = appendQueuedItem(
+      current.queue,
+      current.queueAttachments,
+      promptToQueue,
+      consumed.consumed
+    );
+    clearSendBookkeeping(host, thread.id);
+    const inFlight = host.activeTurns.has(thread.id) || host.startingTurns.has(thread.id) || current.status === "running";
+    shouldSteer = followUp === "steer" && (inFlight || current.queue.length > 0);
+    const patch = queued;
+    if (explicit === void 0 && consumed.consumed.length > 0) {
+      patch.attachments = consumed.attachments;
+    }
+    if (!inFlight) patch.status = "queued";
+    const pid = current.agentPid;
+    if (typeof pid === "number" && pid > 0 && !host.pidAlive(pid)) {
+      patch.agentPid = null;
+    }
+    updateThread(thread.id, patch);
+    host.emit({ type: "queue_changed", threadId: thread.id, queue: queued.queue });
+    if (!inFlight) {
+      host.emit({ type: "status_changed", threadId: thread.id, status: "queued" });
+    }
+    if (thisProcessShouldDrainAgentQueues() && !shouldSteer) {
+      host.armDrain(thread.id);
+    }
+    return host.requireThread(thread.id);
+  });
+  return { thread: sent, shouldSteer };
+}
+
 // src/agents/instructions.ts
 import { existsSync as existsSync12 } from "fs";
 import { join as join12 } from "path";
@@ -6815,7 +6967,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-2SXK4U65.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-NCA4LSCC.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6931,10 +7083,6 @@ async function waitForPidExit(pid, timeoutMs) {
   }
   return true;
 }
-function resolveSendFollowUp(thread, requested) {
-  if (requested === "steer" || requested === "queue") return requested;
-  return isOrchestratorThread(thread) ? followUpBehavior() : "queue";
-}
 function resolveOrchChildFollowUp(requested) {
   if (requested === "steer" || requested === "queue") return requested;
   return followUpBehavior();
@@ -6963,6 +7111,13 @@ var Orchestrator = class {
   draining = /* @__PURE__ */ new Set();
   /** Threads past setStatus(running) but not yet in activeTurns (spawn in flight). */
   startingTurns = /* @__PURE__ */ new Set();
+  /**
+   * Prompt for the turn that has not been answered yet. Steer follow-ups before
+   * any agent output are joined onto this text instead of starting a second bubble.
+   */
+  openSteerPrompt = /* @__PURE__ */ new Map();
+  /** Next runTurn should keep the user bubble already rewritten to this prompt. */
+  reusedUserPrompt = /* @__PURE__ */ new Set();
   /** Last sync thread-file read for false-stop heal (throttled per thread). */
   lastReconcileHealAt = /* @__PURE__ */ new Map();
   /** Per-repo timestamp of the last `reconcile(repo, { light: true })`. */
@@ -7573,54 +7728,29 @@ var Orchestrator = class {
     return thread;
   }
   async send(threadRef, prompt, opts) {
-    const thread = this.requireThread(threadRef);
-    if (thread.status === "archived") {
-      throw new Error(`Thread is archived: ${thread.id}`);
-    }
-    let shouldSteer = false;
-    const sent = await withThreadLock(thread.id, async () => {
-      const current = this.requireThread(thread.id);
-      if (current.status === "archived") {
-        throw new Error(`Thread is archived: ${thread.id}`);
-      }
-      const followUp = resolveSendFollowUp(current, opts?.followUp);
-      const explicit = opts?.attachments;
-      const consumed = explicit !== void 0 ? { attachments: current.attachments, consumed: explicit } : consumeComposerAttachments(current);
-      const queued = appendQueuedItem(
-        current.queue,
-        current.queueAttachments,
-        prompt,
-        consumed.consumed
-      );
-      this.crashContinued.delete(thread.id);
-      this.jobContinueCount.delete(thread.id);
-      this.jobContinueNudged.delete(thread.id);
-      this.haltDrain.delete(thread.id);
-      const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id) || current.status === "running";
-      shouldSteer = followUp === "steer" && (inFlight || current.queue.length > 0);
-      const patch = queued;
-      if (explicit === void 0 && consumed.consumed.length > 0) {
-        patch.attachments = consumed.attachments;
-      }
-      if (!inFlight) patch.status = "queued";
-      const pid = current.agentPid;
-      if (typeof pid === "number" && pid > 0 && !isPidAlive(pid)) {
-        patch.agentPid = null;
-      }
-      updateThread(thread.id, patch);
-      this.emit({ type: "queue_changed", threadId: thread.id, queue: queued.queue });
-      if (!inFlight) {
-        this.emit({ type: "status_changed", threadId: thread.id, status: "queued" });
-      }
-      if (thisProcessShouldDrainAgentQueues() && !shouldSteer) {
-        this.armDrain(thread.id);
-      }
-      return this.requireThread(thread.id);
-    });
-    if (shouldSteer && sent.queue.length > 0) {
-      return this.sendQueuedMessageNow(sent.id, sent.queue.length - 1);
+    const sent = await enqueueThreadSend(
+      {
+        activeTurns: this.activeTurns,
+        startingTurns: this.startingTurns,
+        openSteerPrompt: this.openSteerPrompt,
+        reusedUserPrompt: this.reusedUserPrompt,
+        crashContinued: this.crashContinued,
+        jobContinueCount: this.jobContinueCount,
+        jobContinueNudged: this.jobContinueNudged,
+        haltDrain: this.haltDrain,
+        emit: (event) => this.emit(event),
+        armDrain: (id) => this.armDrain(id),
+        requireThread: (ref) => this.requireThread(ref),
+        pidAlive: (pid) => isPidAlive(pid)
+      },
+      threadRef,
+      prompt,
+      opts
+    );
+    if (sent.shouldSteer && sent.thread.queue.length > 0) {
+      return this.sendQueuedMessageNow(sent.thread.id, sent.thread.queue.length - 1);
     }
-    return sent;
+    return sent.thread;
   }
   async fanOut(threadRefs, prompt, opts) {
     const results = [];
@@ -7777,6 +7907,10 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId, status: "running" });
     this.emit({ type: "turn_started", threadId, prompt });
     try {
+      this.openSteerPrompt.set(threadId, {
+        text: typeof prompt === "string" ? prompt : "",
+        spawned: false
+      });
       try {
         const baseline = await captureTurnBaseline(thread.worktreePath);
         if (baseline) this.turnBaselines.set(threadId, baseline);
@@ -7802,18 +7936,21 @@ var Orchestrator = class {
         this.emit({ type: "error", threadId, message: `context compact failed: ${message}` });
         thread = this.requireThread(threadId);
       }
-      const promptText = typeof prompt === "string" ? prompt : "";
+      const promptText = this.openSteerPrompt.get(threadId)?.text ?? (typeof prompt === "string" ? prompt : "");
       const autoContinue = isJobContinuePrompt(promptText) || promptText.startsWith("The previous agent process ended before it finished.");
       const parked = takePendingTurnAttachments(thread);
       const sentAttachments = !autoContinue && parked.length > 0 ? parked : void 0;
       if (!autoContinue) clearAgentBlock(threadId);
-      appendMessage(threadId, {
-        role: "user",
-        text: promptText,
-        ...sentAttachments ? { attachments: sentAttachments } : {},
-        ...autoContinue ? { origin: "continue" } : {},
-        ts: (/* @__PURE__ */ new Date()).toISOString()
-      });
+      const lastShown = this.requireThread(threadId).messages.at(-1);
+      if (!reuseJoinedUserBubble(this.reusedUserPrompt, threadId, lastShown, promptText)) {
+        appendMessage(threadId, {
+          role: "user",
+          text: promptText,
+          ...sentAttachments ? { attachments: sentAttachments } : {},
+          ...autoContinue ? { origin: "continue" } : {},
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       if (!autoContinue) {
         const live = this.requireThread(threadId);
         const stamp = agentPurposeStamp({
@@ -8012,11 +8149,22 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
       ].filter(Boolean).join("\n\n---\n\n");
       const stderrTail = [];
       traceTurn("runTurn.beforeSpawn", { threadId, agent: fresh.agent });
+      const steerDraft = this.openSteerPrompt.get(threadId);
+      if (steerDraft) steerDraft.spawned = true;
+      const promptForAgent = promptForJoinedSteer({
+        threadId,
+        promptText,
+        latestPrompt: steerDraft?.text ?? promptText,
+        agentPrompt,
+        expandedPrompt,
+        worktreePath: fresh.worktreePath,
+        attachments: autoContinue ? [] : sentAttachments ?? []
+      });
       const handle = await spawnAgentTurn(
         fresh,
         {
           cachedPrefix,
-          prompt: agentPrompt,
+          prompt: promptForAgent,
           systemPrompt: turnReminders,
           isolateCodexPlugins: fresh.isolateCodexPlugins === true
         },
@@ -8144,7 +8292,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
           retryThread,
           {
             cachedPrefix: retryPrefix,
-            prompt: agentPrompt,
+            prompt: promptForAgent,
             systemPrompt: turnReminders,
             isolateCodexPlugins: isolateCodexPluginRetry || retryThread.isolateCodexPlugins === true
           },
@@ -8304,6 +8452,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
     } finally {
       this.startingTurns.delete(threadId);
       this.activeTurns.delete(threadId);
+      this.openSteerPrompt.delete(threadId);
       this.processes.delete(`${threadId}:agent`);
       this.stoppedTurns.delete(threadId);
       this.runningCount = Math.max(0, this.runningCount - 1);
@@ -9867,6 +10016,9 @@ export {
   discoverSkills,
   readSkillBody,
   expandComposerPrompt,
+  joinSteerPrompt,
+  trailingUnansweredUserText,
+  livePartsShowAgentReply,
   consumeComposerAttachments,
   takePendingTurnAttachments,
   alignQueueAttachments,
@@ -9875,6 +10027,7 @@ export {
   removeQueuedItem,
   moveQueuedItemToFront,
   shiftQueuedItem,
+  resolveSendFollowUp,
   packagedDetachedJobPath,
   resolveDetachedJobScript,
   formatDetachedJobInvoke,
@@ -9914,7 +10067,6 @@ export {
   RUN_SCRIPT_DESKTOP_ADOPT_MS,
   isPidAlive,
   waitForPidExit,
-  resolveSendFollowUp,
   resolveOrchChildFollowUp,
   LIGHT_RECONCILE_THROTTLE_MS,
   Orchestrator,

package/dist/{chunk-W5QZWAUB.js → chunk-WLZHRNE6.js}

@@ -1,13 +1,13 @@
 import {
   abletimeRestUrl,
   textFromAbleTimeDoc
-} from "./chunk-2HOZMSKQ.js";
+} from "./chunk-AUJ4XB6H.js";
 import {
   assertAbleTimeCredential,
   callAbleTimeTool,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-7ADEYEMH.js";
+} from "./chunk-LXBZQP2Q.js";
 import {
   httpFetch
 } from "./chunk-JAT3JFOS.js";
@@ -549,9 +549,12 @@ function issueAttachmentForAbleTimeTask(task) {
     ].filter(Boolean).join("\n")
   };
 }
+function ableTimeStateIsClosed(state) {
+  const value = (state ?? "").trim().toLowerCase();
+  return Boolean(value && CLOSED_STATES.has(value));
+}
 function isOpenTask(task) {
-  const state = (task.state ?? "").toLowerCase();
-  return !state || !CLOSED_STATES.has(state);
+  return !ableTimeStateIsClosed(task.state);
 }
 async function getAbleTimeOrientation(opts) {
   const raw = await callAbleTimeTool("orientation", {}, opts);
@@ -847,6 +850,7 @@ export {
   mapAbleTimeTask,
   toAbleTimeIssueInfo,
   issueAttachmentForAbleTimeTask,
+  ableTimeStateIsClosed,
   getAbleTimeOrientation,
   listAbleTimeProjects,
   listAbleTimeTasks,

package/dist/{chunk-7SCVGGF6.js → chunk-ZM43NTJJ.js}

@@ -155,7 +155,7 @@ function textsFromUnknown(value) {
   return "";
 }
 async function abletimeMcpRequest(method, params, opts) {
-  const rawToken = opts?.token ?? await import("./abletime-oauth-S4AXA4WR.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-2VWQCXGT.js").then((m) => m.ensureAbleTimeAccessToken());
   if (!rawToken?.trim()) {
     throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
   }
@@ -226,9 +226,9 @@ async function callAbleTimeTool(name, args = {}, opts) {
   if (!opts?.token && !isAbleTimeConnected()) {
     throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
   }
-  const rawToken = opts?.token ?? await import("./abletime-oauth-S4AXA4WR.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-2VWQCXGT.js").then((m) => m.ensureAbleTimeAccessToken());
   if (rawToken && ableTimeUsesRest(rawToken)) {
-    const { callAbleTimeRestTool } = await import("./abletime-rest-ORBELZQO.js");
+    const { callAbleTimeRestTool } = await import("./abletime-rest-7NICZYOC.js");
     return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
   }
   const requestOpts = { ...opts, pm: opts?.pm ?? abletimeToolUsesPm(name) };
@@ -244,7 +244,7 @@ async function callAbleTimeTool(name, args = {}, opts) {
       return await call();
     }
     if (rawToken && ableTimeUsesRest(rawToken) && isAbleTimeRejectedCredential(message)) {
-      const { callAbleTimeRestTool } = await import("./abletime-rest-ORBELZQO.js");
+      const { callAbleTimeRestTool } = await import("./abletime-rest-7NICZYOC.js");
       return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
     }
     throw err instanceof Error ? new Error(rewriteAbleTimeError(err.message)) : err;