bosun 0.41.0 → 0.41.2

package/task/task-executor-pipeline.mjs

@@ -0,0 +1,143 @@
+/**
+ * @module task/task-executor-pipeline
+ * @description Pipeline orchestration helpers extracted from task-executor.
+ */
+
+import { FanoutPipeline, RacePipeline, SequentialPipeline } from "./pipeline.mjs";
+
+function toAgentList(agents) {
+  if (Array.isArray(agents)) return agents.filter(Boolean);
+  return [agents].filter(Boolean);
+}
+
+function normalizeMode(mode) {
+  return String(mode || "single").trim().toLowerCase();
+}
+
+function buildStageRunner(agent, stageIndex, runner) {
+  const id = String(agent?.id || agent?.name || `agent-${stageIndex + 1}`);
+  const name = String(agent?.name || agent?.id || id);
+  return {
+    ...agent,
+    id,
+    name,
+    async run(input, context) {
+      return runner(agent, input, context);
+    },
+  };
+}
+
+export function createExecutionPipeline(mode = "single", agents = [], options = {}) {
+  const list = toAgentList(agents);
+  if (list.length === 0) {
+    throw new Error("At least one pipeline agent is required");
+  }
+
+  const runAgent =
+    typeof options.agentRunner === "function" ? options.agentRunner : null;
+  if (!runAgent) {
+    throw new Error("Execution pipeline requires options.agentRunner");
+  }
+
+  const normalizedMode = normalizeMode(mode);
+  const stages = list.map((agent, stageIndex) =>
+    buildStageRunner(agent, stageIndex, runAgent));
+  const pipelineOptions = {
+    id: options.id || `${options.task?.id || "task"}-${normalizedMode}`,
+    name: options.name || `${normalizedMode}-execution`,
+    metadata: {
+      taskId: options.task?.id || null,
+      mode: normalizedMode,
+      source: "task-executor",
+      ...(options.metadata && typeof options.metadata === "object" ? options.metadata : {}),
+    },
+  };
+
+  if (["parallel", "fanout", "parallel-slots"].includes(normalizedMode)) {
+    return FanoutPipeline(stages, pipelineOptions);
+  }
+  if (["failover", "race"].includes(normalizedMode)) {
+    return RacePipeline(stages, pipelineOptions);
+  }
+  return SequentialPipeline(stages, pipelineOptions);
+}
+
+export async function runExecutionPipeline(mode, agents, input, options = {}) {
+  const pipeline = createExecutionPipeline(mode, agents, options);
+  return pipeline.run(input, {
+    metadata: options.metadata || {},
+    signal: options.signal || null,
+  });
+}
+
+export async function runExecutionPipelineAgent(
+  agent,
+  input,
+  context,
+  options = {},
+) {
+  const runWithRetry = options.execWithRetry;
+  if (typeof runWithRetry !== "function") {
+    throw new Error("runExecutionPipelineAgent requires options.execWithRetry");
+  }
+
+  const prompt =
+    typeof agent?.prompt === "string" && agent.prompt.trim()
+      ? agent.prompt
+      : [
+          "Task execution pipeline",
+          `Mode: ${context?.options?.metadata?.mode || context?.pipelineType || "sequential"}`,
+          `Agent role: ${agent?.role || agent?.name || agent?.id || "agent"}`,
+          "Use only the structured input below; do not rely on prior conversation state.",
+          typeof input === "string" ? input : JSON.stringify(input, null, 2),
+        ]
+          .filter(Boolean)
+          .join("\n\n");
+
+  const stageIndex = Number.isInteger(context?.stageIndex)
+    ? context.stageIndex
+    : Number.isInteger(context?.agentIndex)
+      ? context.agentIndex
+      : 0;
+  const pipelineId = String(
+    context?.options?.id || context?.runId || context?.pipeline?.id || "pipeline",
+  );
+  const taskKey = `${pipelineId}-${agent?.id || agent?.name || "agent"}-${stageIndex + 1}`;
+  const result = await runWithRetry(prompt, {
+    taskKey,
+    cwd: options.repoRoot || process.cwd(),
+    timeoutMs: Number(agent?.timeoutMs || options.timeoutMs || 0) || undefined,
+    maxRetries: Number(agent?.maxRetries || 1) || 1,
+    sdk: agent?.sdk || agent?.executor || undefined,
+    model: agent?.model || undefined,
+    sessionType: "task-pipeline",
+    signal: context?.signal || null,
+  });
+
+  if (!result?.success) {
+    throw new Error(result?.error || `Pipeline agent ${agent?.id || "agent"} failed`);
+  }
+
+  return {
+    success: true,
+    output: {
+      text: result.output,
+      sdk: result.sdk,
+      taskKey,
+    },
+    text: result.output,
+    meta: {
+      taskKey,
+      sdk: result.sdk,
+    },
+    tokensUsed:
+      Number(result.tokensUsed || result.usage?.totalTokens || result.usage?.total_tokens || 0) ||
+      0,
+  };
+}
+
+export default {
+  createExecutionPipeline,
+  runExecutionPipeline,
+  runExecutionPipelineAgent,
+};

package/task/task-executor.mjs

@@ -102,6 +102,11 @@ import {
 } from "./task-claims.mjs";
 import { initPresence, getPresenceState } from "../infra/presence.mjs";
 import { getSharedState } from "../workspace/shared-state-manager.mjs";
+import {
+  createExecutionPipeline as createTaskExecutionPipeline,
+  runExecutionPipeline as runTaskExecutionPipeline,
+  runExecutionPipelineAgent,
+} from "./task-executor-pipeline.mjs";
 
 // ── Constants ───────────────────────────────────────────────────────────────
 
@@ -3981,38 +3986,18 @@ class TaskExecutor {
       const isFreshEnough =
         ageMs === 0 || ageMs <= INPROGRESS_RECOVERY_MAX_AGE_MS;
 
-      // In workflow-owned mode, calling executeTask() fires task.assigned
-      // which launches a new workflow run. If one already exists (evidenced by
-      // an alive agent thread), that creates two competing runs → owner_mismatch.
-      // trigger.task_assigned workflows don't call action.claim_task, so ownerId
-      // is null and the shared-state guard above cannot protect against this.
-      // • Active thread → workflow is still managing it; leave it alone.
-      // • No active thread but fresh → agent died; reset to todo so
-      //   trigger.task_available re-dispatches cleanly, without double-dispatch.
+      // In workflow-owned mode, executor thread presence is not a reliable
+      // liveness signal because workflow nodes can be actively running before
+      // any executor thread key is observable. Resetting "fresh" in-progress
+      // tasks here causes live runs to churn todo↔inprogress. Keep fresh tasks
+      // in-progress and let stale/unstarted guards above handle true stranding.
       if (this.workflowOwnsTaskLifecycle) {
         if (hasThread) {
           skippedForActiveClaim++;
           continue;
         }
         if (isFreshEnough) {
-          try {
-            await transitionTaskStatus(id, "todo", {
-              source: "task-executor-recovery-workflow-owned",
-            });
-          } catch {
-            /* best effort */
-          }
-          try {
-            transitionInternalTaskStatus(
-              id,
-              "todo",
-              "task-executor-recovery-workflow-owned",
-            );
-          } catch {
-            /* best effort */
-          }
-          this._removeRuntimeSlot(id);
-          resetToTodo++;
+          skippedForActiveClaim++;
           continue;
         }
       }
@@ -5041,6 +5026,30 @@ class TaskExecutor {
     // See workflow-templates/task-lifecycle.mjs
   }
 
+  createExecutionPipeline(mode = "single", agents = [], options = {}) {
+    return createTaskExecutionPipeline(mode, agents, {
+      ...options,
+      agentRunner:
+        options.agentRunner || this._runExecutionPipelineAgent.bind(this),
+    });
+  }
+
+  async runExecutionPipeline(mode, agents, input, options = {}) {
+    return await runTaskExecutionPipeline(mode, agents, input, {
+      ...options,
+      agentRunner:
+        options.agentRunner || this._runExecutionPipelineAgent.bind(this),
+    });
+  }
+
+  async _runExecutionPipelineAgent(agent, input, context) {
+    return runExecutionPipelineAgent(agent, input, context, {
+      execWithRetry,
+      repoRoot: this.repoRoot || process.cwd(),
+      timeoutMs: this.timeoutMs || 0,
+    });
+  }
+
   // ── Task Execution ────────────────────────────────────────────────────────
 
   _getWorktreeManager(repoRoot) {
@@ -5491,7 +5500,7 @@ export function loadExecutorOptionsFromConfig() {
   return {
     mode: envMode || configExec.mode || "internal",
     maxParallel: Number(
-      process.env.INTERNAL_EXECUTOR_PARALLEL || configExec.maxParallel || 3,
+      process.env.INTERNAL_EXECUTOR_PARALLEL || configExec.maxParallel || 5,
     ),
     baseBranchParallelLimit: Number(
       process.env.INTERNAL_EXECUTOR_BASE_BRANCH_PARALLEL ||

package/telegram/get-telegram-chat-id.mjs

@@ -1,71 +1,81 @@
 #!/usr/bin/env node
 
-const token = process.env.TELEGRAM_BOT_TOKEN;
-
-if (!token) {
-  console.error("Missing TELEGRAM_BOT_TOKEN environment variable.");
-  process.exit(1);
-}
-
-const url = `https://api.telegram.org/bot${token}/getUpdates`;
-
-async function main() {
-  let res;
-  try {
-    res = await fetch(url);
-  } catch (err) {
-    console.error(`Fetch error: ${err.message}`);
-    process.exit(1);
-  }
-
-  if (!res.ok) {
-    const body = await res.text();
-    console.error(`Request failed: ${res.status} ${body}`);
-    process.exit(1);
-  }
-
-  const data = await res.json();
-  if (!data.result || data.result.length === 0) {
-    console.log(
-      "No updates found. Send a message to the bot first, then retry.",
-    );
-    return;
-  }
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
+export function extractTelegramChatsFromUpdates(updates) {
   const chats = new Map();
-  for (const update of data.result) {
-    const message =
-      update.message || update.channel_post || update.edited_message;
-    if (!message || !message.chat) {
+  for (const update of Array.isArray(updates) ? updates : []) {
+    const message = update?.message || update?.channel_post || update?.edited_message;
+    const chat = message?.chat;
+    if (!chat?.id) {
       continue;
     }
-    const chat = message.chat;
     if (!chats.has(chat.id)) {
       chats.set(chat.id, {
         id: chat.id,
-        type: chat.type,
+        type: chat.type || "unknown",
         title: chat.title || "",
         username: chat.username || "",
       });
     }
   }
+  return Array.from(chats.values());
+}
+
+export async function discoverTelegramChats(token, { fetchImpl = fetch } = {}) {
+  const normalizedToken = String(token || "").trim();
+  if (!normalizedToken) {
+    throw new Error("Missing TELEGRAM_BOT_TOKEN environment variable.");
+  }
+
+  const url = `https://api.telegram.org/bot${normalizedToken}/getUpdates`;
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Request failed: ${response.status}${body ? ` ${body}` : ""}`);
+  }
 
-  if (chats.size === 0) {
-    console.log(
-      "No chat IDs found in updates. Send a message to the bot first.",
-    );
+  const data = await response.json();
+  const updates = data?.result;
+  const chats = extractTelegramChatsFromUpdates(updates);
+  if (Array.isArray(updates) && updates.length === 0) {
+    return {
+      chats,
+      message: "No updates found. Send a message to the bot first, then retry.",
+    };
+  }
+  if (chats.length === 0) {
+    return {
+      chats,
+      message: "No chat IDs found in updates. Send a message to the bot first.",
+    };
+  }
+  return { chats, message: null };
+}
+
+async function main() {
+  const token = process.env.TELEGRAM_BOT_TOKEN;
+  const { chats, message } = await discoverTelegramChats(token);
+  if (message) {
+    console.log(message);
     return;
   }
 
   console.log("Found chat IDs:");
-  for (const chat of chats.values()) {
-    const titlePart = chat.title ? ` title=\"${chat.title}\"` : "";
+  for (const chat of chats) {
+    const titlePart = chat.title ? ` title="${chat.title}"` : "";
     const userPart = chat.username ? ` username=@${chat.username}` : "";
     console.log(`- id=${chat.id} type=${chat.type}${userPart}${titlePart}`);
   }
 }
 
-main().catch((err) => {
-  console.error(`Error: ${err.message || err}`);
-  process.exit(1);
-});
+const __filename = fileURLToPath(import.meta.url);
+if (process.argv[1] && resolve(process.argv[1]) === resolve(__filename)) {
+  try {
+    await main();
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  }
+}

package/ui/components/workspace-switcher.js

@@ -470,7 +470,7 @@ function ExecutorConfigPanel({ ws }) {
 
       <${Collapse} in=${expanded}>
         <${Stack} spacing=${1.5} sx=${{ pt: 1, pb: 0.5, px: 0.5 }}>
-          <!-- Max concurrent executors -->
+
           <${Box}>
             <${Typography} variant="caption" color="text.secondary" sx=${{ mb: 0.5, display: "block" }}>
               Max Concurrent Executors: ${maxConcurrent}
@@ -492,7 +492,7 @@ function ExecutorConfigPanel({ ws }) {
             />
           <//>
 
-          <!-- Pool mode -->
+
           <${Stack} direction="row" spacing=${1} alignItems="center">
             <${Typography} variant="caption" color="text.secondary">Pool:<//>
             <${ToggleButtonGroup}
@@ -515,7 +515,7 @@ function ExecutorConfigPanel({ ws }) {
             <//>
           <//>
 
-          <!-- Weight (only for shared pool) -->
+
           ${pool === "shared" && html`
             <${Box}>
               <${Typography} variant="caption" color="text.secondary" sx=${{ mb: 0.5, display: "block" }}>
@@ -533,7 +533,7 @@ function ExecutorConfigPanel({ ws }) {
             <//>
           `}
 
-          <!-- Save button -->
+
           ${hasChanges && html`
             <${Button}
               size="small"
@@ -630,12 +630,12 @@ function WorkspaceCard({ ws }) {
           <//>
         <//>
 
-        <!-- State toggle row -->
+
         <${Box} sx=${{ mt: 1.5, mb: 0.5 }}>
           <${WorkspaceStateToggle} ws=${ws} />
         <//>
 
-        <!-- Executor config -->
+
         <${ExecutorConfigPanel} ws=${ws} />
       <//>
 
@@ -780,7 +780,7 @@ export function WorkspaceManager({ open, onClose }) {
 
   return html`
     <${Modal} title="Manage Workspaces" open=${open} onClose=${onClose}>
-      <!-- State summary bar -->
+
       ${wsList.length > 0 && html`
         <${Stack} direction="row" spacing=${1.5} sx=${{ mb: 2 }} alignItems="center">
           ${Object.entries(STATE_CONFIG).map(([key, cfg]) => html`