@sideboard-ai/core 0.1.318 → 0.1.319

package/dist/index.cjs

@@ -8685,18 +8685,18 @@ function mcpWaitForTurnTimeoutMs(requested) {
   if (!Number.isFinite(n)) return MCP_WAIT_FOR_TURN_MAX_MS;
   return Math.min(Math.max(1e3, Math.floor(n)), MCP_WAIT_FOR_TURN_MAX_MS);
 }
-function mcpWaitTaskHint(taskState, status, blockedReason) {
+function mcpWaitTaskHint(taskState2, status, blockedReason) {
   const why = blockedReason?.trim();
-  if (why && taskState !== "failed" && taskState !== "canceled") {
-    if (taskState === "submitted" || taskState === "working") {
+  if (why && taskState2 !== "failed" && taskState2 !== "canceled") {
+    if (taskState2 === "submitted" || taskState2 === "working") {
       return `Child is blocked: ${why} It has not finished the turn. Do not send_to_chat a check-in.`;
     }
-    if (taskState === "input-required") {
+    if (taskState2 === "input-required") {
       return `Child is blocked: ${why} Wait for the user in that chat \u2014 do not send_to_chat a check-in.`;
     }
     return `Child is blocked: ${why} Help if this is your child; otherwise tell the user. Do not send_to_chat a check-in.`;
   }
-  switch (taskState) {
+  switch (taskState2) {
     case "submitted":
       return MCP_WAIT_QUEUED_HINT;
     case "working":
@@ -24886,6 +24886,7 @@ var init_abletime_projects = __esm({
 var abletime_exports = {};
 __export(abletime_exports, {
   ableTimeDependencyTarget: () => ableTimeDependencyTarget,
+  ableTimeStateIsClosed: () => ableTimeStateIsClosed,
   commentAbleTimeTask: () => commentAbleTimeTask,
   createAbleTimeTask: () => createAbleTimeTask,
   downloadAbleTimeAttachment: () => downloadAbleTimeAttachment,
@@ -25039,9 +25040,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);
@@ -28329,6 +28333,41 @@ var init_expand = __esm({
   }
 });
 
+// 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 text7 = (message.text ?? "").trim();
+      if (text7 || (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;
+}
+var init_agent_has_replied = __esm({
+  "src/composer/agent-has-replied.ts"() {
+    "use strict";
+  }
+});
+
 // src/composer/consume-attachments.ts
 function consumeComposerAttachments(thread) {
   return {
@@ -28386,6 +28425,142 @@ var init_consume_attachments = __esm({
   }
 });
 
+// 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 };
+}
+var init_enqueue_thread_send = __esm({
+  "src/orchestrator/enqueue-thread-send.ts"() {
+    "use strict";
+    init_agent_git_actions();
+    init_agent_has_replied();
+    init_expand();
+    init_consume_attachments();
+    init_desktop_host();
+    init_thread_store();
+    init_turn_live();
+    init_app_settings();
+    init_global_workspace();
+  }
+});
+
 // src/skills/detached-job-path.ts
 function compiledModuleDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
@@ -29756,10 +29931,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();
@@ -29909,6 +30080,7 @@ var init_orchestrator = __esm({
     init_read_worktree_tail();
     init_discover();
     init_expand();
+    init_enqueue_thread_send();
     init_consume_attachments();
     init_stage_files();
     init_context_compact();
@@ -29926,6 +30098,7 @@ var init_orchestrator = __esm({
     init_caffeinate_hold();
     init_schedule_runner();
     init_coordinator_prompt();
+    init_enqueue_thread_send();
     LIVE_TURN_SPAWN_GRACE_MS = 15e3;
     RUN_SCRIPT_DESKTOP_ADOPT_MS = 2e4;
     STALE_AGENT_PID_WAIT_MS = 2500;
@@ -29937,6 +30110,13 @@ var init_orchestrator = __esm({
       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 })`. */
@@ -30547,54 +30727,29 @@ var init_orchestrator = __esm({
         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 = [];
@@ -30751,6 +30906,10 @@ var init_orchestrator = __esm({
         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);
@@ -30776,18 +30935,21 @@ var init_orchestrator = __esm({
             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({
@@ -30986,11 +31148,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
             },
@@ -31118,7 +31291,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
               retryThread,
               {
                 cachedPrefix: retryPrefix,
-                prompt: agentPrompt,
+                prompt: promptForAgent,
                 systemPrompt: turnReminders,
                 isolateCodexPlugins: isolateCodexPluginRetry || retryThread.isolateCodexPlugins === true
               },
@@ -31278,6 +31451,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);
@@ -31954,7 +32128,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         const live = stillRunning ? readTurnLive(thread.id) : null;
         const liveSummary = live?.summary && !isInternalAgentStatusText(live.summary) ? live.summary : null;
         const queuedHint = stillRunning && thread.status === "queued" && !liveSummary ? "Queued \u2014 waiting for a concurrency slot" : null;
-        const taskState = deriveTaskState({
+        const taskState2 = deriveTaskState({
           status: thread.status,
           stillRunning,
           lastAgentParts: lastAgent?.parts
@@ -31963,7 +32137,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         return {
           text: text7,
           status: thread.status,
-          taskState,
+          taskState: taskState2,
           sessionId: thread.sessionId,
           lastError,
           stillRunning,
@@ -32907,6 +33081,7 @@ __export(index_exports, {
   ableTimeOAuthLocalBounceUrl: () => ableTimeOAuthLocalBounceUrl,
   ableTimeOAuthRedirectUri: () => ableTimeOAuthRedirectUri,
   ableTimeOAuthResource: () => ableTimeOAuthResource,
+  ableTimeStateIsClosed: () => ableTimeStateIsClosed,
   ableTimeUsesRest: () => ableTimeUsesRest,
   abletimeMcpRequest: () => abletimeMcpRequest,
   abletimeMcpUrl: () => abletimeMcpUrl,
@@ -33389,6 +33564,7 @@ __export(index_exports, {
   issueMatchesAssignee: () => issueMatchesAssignee,
   issueSourceLabel: () => issueSourceLabel,
   issueTicketFromThread: () => issueTicketFromThread,
+  joinSteerPrompt: () => joinSteerPrompt,
   killDetachedRunTree: () => killDetachedRunTree,
   killListenersOnPorts: () => killListenersOnPorts,
   killStaleWorktreeListeners: () => killStaleWorktreeListeners,
@@ -33447,6 +33623,7 @@ __export(index_exports, {
   listWorktrees: () => listWorktrees,
   listenerCwd: () => listenerCwd,
   liveActivitySummary: () => liveActivitySummary,
+  livePartsShowAgentReply: () => livePartsShowAgentReply,
   loadAppSettings: () => loadAppSettings,
   loadBrightsyConfig: () => loadBrightsyConfig,
   loadConductorSettings: () => loadConductorSettings,
@@ -33784,6 +33961,7 @@ __export(index_exports, {
   toolDetail: () => toolDetail,
   toolFilePath: () => toolFilePath,
   totalTokens: () => totalTokens,
+  trailingUnansweredUserText: () => trailingUnansweredUserText,
   trustSystemCertificates: () => trustSystemCertificates,
   tryReservePort: () => tryReservePort,
   tryReservePorts: () => tryReservePorts,
@@ -41754,6 +41932,7 @@ init_discover();
 init_detached_job_path();
 init_long_running();
 init_expand();
+init_agent_has_replied();
 
 // src/composer/diff-comment.ts
 function lineRangeLabel(lines) {
@@ -45568,6 +45747,7 @@ init_profile();
 init_home_board();
 
 // src/integrations/abletime-blocked.ts
+init_abletime();
 init_abletime_mcp();
 init_abletime_rest();
 function asRecord18(value) {
@@ -45592,6 +45772,9 @@ function firstRecord2(record, keys) {
   }
   return null;
 }
+function taskState(record) {
+  return firstString5(record, ["state", "board_state", "boardState", "status", "taskState"]);
+}
 function identifierFromUnknown(value) {
   if (typeof value === "string" || typeof value === "number") {
     const id2 = String(value).trim();
@@ -45603,6 +45786,7 @@ function identifierFromUnknown(value) {
   for (const key of ["nodes", "data", "tasks", "items"]) {
     if (Array.isArray(rec[key])) return identifierFromUnknown(rec[key]);
   }
+  if (ableTimeStateIsClosed(taskState(rec))) return [];
   const id = firstString5(rec, ["identifier", "reference", "ref", "key", "code", "number", "id"]);
   return id ? [id] : [];
 }
@@ -45637,6 +45821,8 @@ async function getAbleTimeIssueBlockedBy(id, opts) {
       continue;
     }
     const parent = await callAbleTimeTool("get_task", { id: blockerId, task_id: blockerId }, opts);
+    const parentRecord = firstRecord2(asRecord18(parent), ["task", "data"]) ?? asRecord18(parent);
+    if (ableTimeStateIsClosed(taskState(parentRecord))) continue;
     const ref = taskReference(parent);
     if (!ref || looksLikeAbleTimeUlid(ref)) {
       throw new Error(`AbleTime blocker has no reference: ${blockerId}`);
@@ -45661,6 +45847,8 @@ function githubBlockedByIdentifiers(payload) {
     const rec = node && typeof node === "object" && !Array.isArray(node) ? node : null;
     const number = Number(rec?.number ?? node);
     if (!Number.isFinite(number) || number <= 0) continue;
+    const state = String(rec?.state ?? "").trim().toUpperCase();
+    if (state === "CLOSED") continue;
     const id = `#${number}`;
     const key = id.toLowerCase();
     if (seen.has(key)) continue;
@@ -45673,7 +45861,7 @@ var GITHUB_BLOCKED_BY_QUERY = `
 query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) {
     issue(number: $number) {
-      blockedBy(first: 25) { nodes { number } }
+      blockedBy(first: 25) { nodes { number state } }
     }
   }
 }
@@ -45721,15 +45909,21 @@ async function getGitHubIssueBlockedBy(id, opts) {
 }
 
 // src/integrations/linear-blocked.ts
+var RESOLVED_LINEAR_STATE = /* @__PURE__ */ new Set(["completed", "canceled", "cancelled", "duplicate"]);
+function linearBlockerStillBlocks(issue) {
+  const type = (issue?.state?.type ?? "").trim().toLowerCase();
+  if (!type) return true;
+  return !RESOLVED_LINEAR_STATE.has(type);
+}
 var ISSUE_BLOCKED_BY_QUERY = `
 query SideboardIssueBlockedBy($id: String!) {
   issue(id: $id) {
     identifier
     relations(first: 25) {
-      nodes { id type relatedIssue { id identifier } }
+      nodes { id type relatedIssue { id identifier state { type } } }
     }
     inverseRelations(first: 25) {
-      nodes { id type issue { id identifier } }
+      nodes { id type issue { id identifier state { type } } }
     }
   }
 }
@@ -45740,6 +45934,7 @@ function linearBlockedByIdentifiers(relations) {
   for (const rel of relations) {
     const type = (rel.type ?? "").trim().toLowerCase().replace(/[\s_-]+/g, "");
     if (type !== "blockedby" && type !== "blocked") continue;
+    if (!linearBlockerStillBlocks(rel.issue)) continue;
     const id = (rel.issue?.identifier || rel.issue?.id || "").trim();
     const key = id.toLowerCase();
     if (!id || seen.has(key)) continue;
@@ -47931,6 +48126,7 @@ async function pollSlackOutboundWatches(opts) {
   ableTimeOAuthLocalBounceUrl,
   ableTimeOAuthRedirectUri,
   ableTimeOAuthResource,
+  ableTimeStateIsClosed,
   ableTimeUsesRest,
   abletimeMcpRequest,
   abletimeMcpUrl,
@@ -48413,6 +48609,7 @@ async function pollSlackOutboundWatches(opts) {
   issueMatchesAssignee,
   issueSourceLabel,
   issueTicketFromThread,
+  joinSteerPrompt,
   killDetachedRunTree,
   killListenersOnPorts,
   killStaleWorktreeListeners,
@@ -48471,6 +48668,7 @@ async function pollSlackOutboundWatches(opts) {
   listWorktrees,
   listenerCwd,
   liveActivitySummary,
+  livePartsShowAgentReply,
   loadAppSettings,
   loadBrightsyConfig,
   loadConductorSettings,
@@ -48808,6 +49006,7 @@ async function pollSlackOutboundWatches(opts) {
   toolDetail,
   toolFilePath,
   totalTokens,
+  trailingUnansweredUserText,
   trustSystemCertificates,
   tryReservePort,
   tryReservePorts,