@sideboard-ai/core 0.1.318 → 0.1.319

package/dist/{abletime-KWOBUL46.js → abletime-DVYO4IVS.js}

@@ -1,5 +1,6 @@
 import {
   ableTimeDependencyTarget,
+  ableTimeStateIsClosed,
   commentAbleTimeTask,
   createAbleTimeTask,
   downloadAbleTimeAttachment,
@@ -16,9 +17,9 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-W5QZWAUB.js";
-import "./chunk-2HOZMSKQ.js";
-import "./chunk-7ADEYEMH.js";
+} from "./chunk-WLZHRNE6.js";
+import "./chunk-AUJ4XB6H.js";
+import "./chunk-LXBZQP2Q.js";
 import "./chunk-JAT3JFOS.js";
 import "./chunk-6K64FJDD.js";
 import "./chunk-E52SQENB.js";
@@ -30,6 +31,7 @@ import "./chunk-JT7R45JB.js";
 import "./chunk-H4UEFJRI.js";
 export {
   ableTimeDependencyTarget,
+  ableTimeStateIsClosed,
   commentAbleTimeTask,
   createAbleTimeTask,
   downloadAbleTimeAttachment,

package/dist/{abletime-TKAFNXCM.js → abletime-L3ODNTBT.js}

@@ -2,6 +2,7 @@
 
 import {
   ableTimeDependencyTarget,
+  ableTimeStateIsClosed,
   commentAbleTimeTask,
   createAbleTimeTask,
   downloadAbleTimeAttachment,
@@ -18,9 +19,9 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-I5CLCWUK.js";
-import "./chunk-VZAJVX36.js";
-import "./chunk-7SCVGGF6.js";
+} from "./chunk-QPLQXWND.js";
+import "./chunk-JD7CC6SW.js";
+import "./chunk-ZM43NTJJ.js";
 import "./chunk-2GPQZZLY.js";
 import "./chunk-N2WW62LF.js";
 import "./chunk-GCHSJCCX.js";
@@ -32,6 +33,7 @@ import "./chunk-KGZBYWZ3.js";
 import "./chunk-WOU343SI.js";
 export {
   ableTimeDependencyTarget,
+  ableTimeStateIsClosed,
   commentAbleTimeTask,
   createAbleTimeTask,
   downloadAbleTimeAttachment,

package/dist/{abletime-oauth-S4AXA4WR.js → abletime-oauth-2VWQCXGT.js}

@@ -3,7 +3,7 @@
 import {
   DEFAULT_ABLETIME_HOST,
   normalizeAbleTimeHost
-} from "./chunk-7SCVGGF6.js";
+} from "./chunk-ZM43NTJJ.js";
 import {
   httpFetch
 } from "./chunk-2GPQZZLY.js";
@@ -288,7 +288,7 @@ async function startAbleTimeOAuth(opts) {
   persistAbleTimeTokens(data, { host });
   const token = data.access_token.trim();
   try {
-    const { getAbleTimeOrientation } = await import("./abletime-TKAFNXCM.js");
+    const { getAbleTimeOrientation } = await import("./abletime-L3ODNTBT.js");
     const orientation = await getAbleTimeOrientation({ token, host });
     return saveAbleTimeConnection({
       accessToken: token,

package/dist/{abletime-oauth-IUIAGLFJ.js → abletime-oauth-6DTX7LB7.js}

@@ -20,8 +20,8 @@ import {
   parseAbleTimeOAuthCallbackUrl,
   resolveAbleTimeOAuthHost,
   startAbleTimeOAuth
-} from "./chunk-XOZNEAWF.js";
-import "./chunk-7ADEYEMH.js";
+} from "./chunk-5OM7UCTQ.js";
+import "./chunk-LXBZQP2Q.js";
 import "./chunk-JAT3JFOS.js";
 import "./chunk-E52SQENB.js";
 import "./chunk-77WWLBCI.js";

package/dist/{abletime-rest-ORBELZQO.js → abletime-rest-7NICZYOC.js}

@@ -7,8 +7,8 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-VZAJVX36.js";
-import "./chunk-7SCVGGF6.js";
+} from "./chunk-JD7CC6SW.js";
+import "./chunk-ZM43NTJJ.js";
 import "./chunk-2GPQZZLY.js";
 import "./chunk-GCHSJCCX.js";
 import "./chunk-NSTQ6QKD.js";

package/dist/{abletime-rest-RWN4EPY3.js → abletime-rest-PYQM234B.js}

@@ -5,8 +5,8 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-2HOZMSKQ.js";
-import "./chunk-7ADEYEMH.js";
+} from "./chunk-AUJ4XB6H.js";
+import "./chunk-LXBZQP2Q.js";
 import "./chunk-JAT3JFOS.js";
 import "./chunk-E52SQENB.js";
 import "./chunk-77WWLBCI.js";

package/dist/{chunk-XOZNEAWF.js → chunk-5OM7UCTQ.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_ABLETIME_HOST,
   normalizeAbleTimeHost
-} from "./chunk-7ADEYEMH.js";
+} from "./chunk-LXBZQP2Q.js";
 import {
   httpFetch
 } from "./chunk-JAT3JFOS.js";
@@ -280,7 +280,7 @@ async function startAbleTimeOAuth(opts) {
   persistAbleTimeTokens(data, { host });
   const token = data.access_token.trim();
   try {
-    const { getAbleTimeOrientation } = await import("./abletime-KWOBUL46.js");
+    const { getAbleTimeOrientation } = await import("./abletime-DVYO4IVS.js");
     const orientation = await getAbleTimeOrientation({ token, host });
     return saveAbleTimeConnection({
       accessToken: token,

package/dist/{chunk-2HOZMSKQ.js → chunk-AUJ4XB6H.js}

@@ -4,7 +4,7 @@ import {
   normalizeAbleTimeCredential,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-7ADEYEMH.js";
+} from "./chunk-LXBZQP2Q.js";
 import {
   httpFetch
 } from "./chunk-JAT3JFOS.js";

package/dist/{chunk-VZAJVX36.js → chunk-JD7CC6SW.js}

@@ -6,7 +6,7 @@ import {
   normalizeAbleTimeCredential,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-7SCVGGF6.js";
+} from "./chunk-ZM43NTJJ.js";
 import {
   httpFetch
 } from "./chunk-2GPQZZLY.js";

package/dist/{chunk-7ADEYEMH.js → chunk-LXBZQP2Q.js}

@@ -153,7 +153,7 @@ function textsFromUnknown(value) {
   return "";
 }
 async function abletimeMcpRequest(method, params, opts) {
-  const rawToken = opts?.token ?? await import("./abletime-oauth-IUIAGLFJ.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-6DTX7LB7.js").then((m) => m.ensureAbleTimeAccessToken());
   if (!rawToken?.trim()) {
     throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
   }
@@ -224,9 +224,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-IUIAGLFJ.js").then((m) => m.ensureAbleTimeAccessToken());
+  const rawToken = opts?.token ?? await import("./abletime-oauth-6DTX7LB7.js").then((m) => m.ensureAbleTimeAccessToken());
   if (rawToken && ableTimeUsesRest(rawToken)) {
-    const { callAbleTimeRestTool } = await import("./abletime-rest-RWN4EPY3.js");
+    const { callAbleTimeRestTool } = await import("./abletime-rest-PYQM234B.js");
     return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
   }
   const requestOpts = { ...opts, pm: opts?.pm ?? abletimeToolUsesPm(name) };
@@ -242,7 +242,7 @@ async function callAbleTimeTool(name, args = {}, opts) {
       return await call();
     }
     if (rawToken && ableTimeUsesRest(rawToken) && isAbleTimeRejectedCredential(message)) {
-      const { callAbleTimeRestTool } = await import("./abletime-rest-RWN4EPY3.js");
+      const { callAbleTimeRestTool } = await import("./abletime-rest-PYQM234B.js");
       return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
     }
     throw err instanceof Error ? new Error(rewriteAbleTimeError(err.message)) : err;

package/dist/{chunk-BXTISNKW.js → chunk-OO3R6CS2.js}

@@ -2691,7 +2691,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-TKAFNXCM.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-L3ODNTBT.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -3210,6 +3210,9 @@ function writeTurnLive(threadId, progress) {
     }
   }
 }
+function readTurnLiveParts(threadId) {
+  return buffers.get(threadId)?.parts.slice() ?? [];
+}
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
   if (!existsSync6(path)) return null;
@@ -5384,6 +5387,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 {
@@ -5436,6 +5469,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";
@@ -6458,7 +6613,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-N54V3B76.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-H3DSZ5RM.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6574,10 +6729,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();
@@ -6606,6 +6757,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 })`. */
@@ -7216,54 +7374,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 = [];
@@ -7420,6 +7553,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);
@@ -7445,18 +7582,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({
@@ -7655,11 +7795,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
         },
@@ -7787,7 +7938,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
           retryThread,
           {
             cachedPrefix: retryPrefix,
-            prompt: agentPrompt,
+            prompt: promptForAgent,
             systemPrompt: turnReminders,
             isolateCodexPlugins: isolateCodexPluginRetry || retryThread.isolateCodexPlugins === true
           },
@@ -7947,6 +8098,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);
@@ -9396,6 +9548,7 @@ export {
   listFleetArchive,
   formatFleetArchive,
   readTurnLive,
+  resolveSendFollowUp,
   localhostPreviewUrl,
   parseIssueSince,
   formatGitHubSearchUpdatedSince,
@@ -9419,7 +9572,6 @@ export {
   RUN_SCRIPT_DESKTOP_ADOPT_MS,
   isPidAlive,
   waitForPidExit,
-  resolveSendFollowUp,
   resolveOrchChildFollowUp,
   LIGHT_RECONCILE_THROTTLE_MS,
   Orchestrator,

package/dist/{chunk-I5CLCWUK.js → chunk-QPLQXWND.js}

@@ -3,13 +3,13 @@
 import {
   abletimeRestUrl,
   textFromAbleTimeDoc
-} from "./chunk-VZAJVX36.js";
+} from "./chunk-JD7CC6SW.js";
 import {
   assertAbleTimeCredential,
   callAbleTimeTool,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-7SCVGGF6.js";
+} from "./chunk-ZM43NTJJ.js";
 import {
   httpFetch
 } from "./chunk-2GPQZZLY.js";
@@ -551,9 +551,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);
@@ -849,6 +852,7 @@ export {
   mapAbleTimeTask,
   toAbleTimeIssueInfo,
   issueAttachmentForAbleTimeTask,
+  ableTimeStateIsClosed,
   getAbleTimeOrientation,
   listAbleTimeProjects,
   listAbleTimeTasks,