bosun 0.29.0 → 0.29.2

package/agent-endpoint.mjs

@@ -20,6 +20,7 @@ import { createServer } from "node:http";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeFileSync, mkdirSync, unlinkSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -505,6 +506,20 @@ export class AgentEndpoint {
         return await this._handleListTasks(url, res);
       }
 
+      if (method === "POST" && pathname === "/api/tasks/create") {
+        const body = await parseBody(req);
+        return await this._handleCreateTask(body, res);
+      }
+
+      if (method === "GET" && pathname === "/api/tasks/stats") {
+        return await this._handleTaskStats(res);
+      }
+
+      if (method === "POST" && pathname === "/api/tasks/import") {
+        const body = await parseBody(req);
+        return await this._handleImportTasks(body, res);
+      }
+
       if (method === "GET" && pathname === "/api/executor") {
         return this._handleExecutorStatus(res);
       }
@@ -545,6 +560,15 @@ export class AgentEndpoint {
           const body = await parseBody(req);
           return await this._handleError(taskId, body, res);
         }
+
+        if (method === "POST" && pathname === `/api/tasks/${taskId}/update`) {
+          const body = await parseBody(req);
+          return await this._handleUpdateTask(taskId, body, res);
+        }
+
+        if (method === "DELETE" && pathname === `/api/tasks/${taskId}`) {
+          return await this._handleDeleteTask(taskId, res);
+        }
       }
 
       // ── 404 ─────────────────────────────────────────────────────────
@@ -864,6 +888,299 @@ export class AgentEndpoint {
     sendJson(res, 200, { ok: true, task, nextAction });
   }
 
+  // ── Task CRUD Handlers ──────────────────────────────────────────────────
+
+  async _handleCreateTask(body, res) {
+    if (!this._taskStore) {
+      sendJson(res, 503, { error: "Task store not configured" });
+      return;
+    }
+
+    const { title, description, status, priority, tags, baseBranch, base_branch, workspace, repository, repositories, implementation_steps, acceptance_criteria, verification, draft } = body;
+
+    if (!title) {
+      sendJson(res, 400, { error: "Missing 'title' in body" });
+      return;
+    }
+
+    try {
+      // Build description from structured fields if provided
+      let fullDescription = description || "";
+      if (implementation_steps?.length || acceptance_criteria?.length || verification?.length) {
+        const parts = [fullDescription];
+        if (implementation_steps?.length) {
+          parts.push("", "## Implementation Steps");
+          for (const step of implementation_steps) parts.push(`- ${step}`);
+        }
+        if (acceptance_criteria?.length) {
+          parts.push("", "## Acceptance Criteria");
+          for (const c of acceptance_criteria) parts.push(`- ${c}`);
+        }
+        if (verification?.length) {
+          parts.push("", "## Verification");
+          for (const v of verification) parts.push(`- ${v}`);
+        }
+        fullDescription = parts.join("\n");
+      }
+
+      let task;
+      if (typeof this._taskStore.createTask === "function") {
+        // kanban adapter — handles ID generation
+        task = await this._taskStore.createTask(null, {
+          title,
+          description: fullDescription,
+          status: status || "draft",
+          priority: priority || "medium",
+          tags: tags || [],
+          baseBranch: baseBranch || base_branch || "main",
+          workspace: workspace || "",
+          repository: repository || "",
+          repositories: repositories || [],
+          draft: draft ?? (status === "draft" || !status),
+        });
+      } else if (typeof this._taskStore.addTask === "function") {
+        // raw task-store
+        task = this._taskStore.addTask({
+          id: randomUUID(),
+          title,
+          description: fullDescription,
+          status: status || "draft",
+          priority: priority || "medium",
+          tags: tags || [],
+          baseBranch: baseBranch || base_branch || "main",
+          workspace: workspace || "",
+          repository: repository || "",
+          repositories: repositories || [],
+          draft: draft ?? (status === "draft" || !status),
+        });
+      } else {
+        sendJson(res, 501, { error: "Task store does not support creation" });
+        return;
+      }
+
+      if (!task) {
+        sendJson(res, 500, { error: "Failed to create task" });
+        return;
+      }
+
+      console.log(`${TAG} Created task ${task.id}: ${task.title}`);
+      sendJson(res, 201, { ok: true, task });
+    } catch (err) {
+      console.error(`${TAG} createTask error:`, err.message);
+      sendJson(res, 500, { error: `Failed to create task: ${err.message}` });
+    }
+  }
+
+  async _handleUpdateTask(taskId, body, res) {
+    if (!this._taskStore) {
+      sendJson(res, 503, { error: "Task store not configured" });
+      return;
+    }
+
+    try {
+      // Verify task exists
+      let existing = null;
+      if (typeof this._taskStore.getTask === "function") {
+        existing = await this._taskStore.getTask(taskId);
+      } else if (typeof this._taskStore.get === "function") {
+        existing = await this._taskStore.get(taskId);
+      }
+      if (!existing) {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+      }
+
+      const updates = { ...body };
+      delete updates.id; // Never allow ID change
+
+      // Normalize base_branch → baseBranch
+      if (updates.base_branch) {
+        updates.baseBranch = updates.base_branch;
+        delete updates.base_branch;
+      }
+
+      // Handle status change with history tracking
+      if (updates.status && updates.status !== existing.status) {
+        if (typeof this._taskStore.updateTaskStatus === "function") {
+          await this._taskStore.updateTaskStatus(taskId, updates.status);
+        }
+        delete updates.status;
+      }
+
+      // Apply remaining updates
+      let updatedTask;
+      if (Object.keys(updates).length > 0) {
+        if (typeof this._taskStore.updateTask === "function") {
+          updatedTask = await this._taskStore.updateTask(taskId, updates);
+        } else if (typeof this._taskStore.update === "function") {
+          updatedTask = await this._taskStore.update(taskId, updates);
+        }
+      }
+
+      // Re-fetch to get final state
+      if (typeof this._taskStore.getTask === "function") {
+        updatedTask = await this._taskStore.getTask(taskId);
+      } else if (typeof this._taskStore.get === "function") {
+        updatedTask = await this._taskStore.get(taskId);
+      }
+
+      console.log(`${TAG} Updated task ${taskId}`);
+      sendJson(res, 200, { ok: true, task: updatedTask || { id: taskId } });
+    } catch (err) {
+      console.error(`${TAG} updateTask(${taskId}) error:`, err.message);
+      sendJson(res, 500, { error: `Failed to update task: ${err.message}` });
+    }
+  }
+
+  async _handleDeleteTask(taskId, res) {
+    if (!this._taskStore) {
+      sendJson(res, 503, { error: "Task store not configured" });
+      return;
+    }
+
+    try {
+      let removed = false;
+      if (typeof this._taskStore.deleteTask === "function") {
+        await this._taskStore.deleteTask(taskId);
+        removed = true;
+      } else if (typeof this._taskStore.removeTask === "function") {
+        removed = this._taskStore.removeTask(taskId);
+      } else {
+        sendJson(res, 501, { error: "Task store does not support deletion" });
+        return;
+      }
+
+      if (!removed) {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+      }
+
+      console.log(`${TAG} Deleted task ${taskId}`);
+      sendJson(res, 200, { ok: true, deleted: taskId });
+    } catch (err) {
+      console.error(`${TAG} deleteTask(${taskId}) error:`, err.message);
+      sendJson(res, 500, { error: `Failed to delete task: ${err.message}` });
+    }
+  }
+
+  async _handleTaskStats(res) {
+    if (!this._taskStore) {
+      sendJson(res, 503, { error: "Task store not configured" });
+      return;
+    }
+
+    try {
+      let stats;
+      if (typeof this._taskStore.getStats === "function") {
+        stats = this._taskStore.getStats();
+      } else {
+        // Compute from list
+        let tasks = [];
+        if (typeof this._taskStore.listTasks === "function") {
+          tasks = await this._taskStore.listTasks(null, {});
+        } else if (typeof this._taskStore.list === "function") {
+          tasks = await this._taskStore.list({});
+        }
+        const list = Array.isArray(tasks) ? tasks : [];
+        stats = {
+          draft: list.filter((t) => t.status === "draft").length,
+          todo: list.filter((t) => t.status === "todo").length,
+          inprogress: list.filter((t) => t.status === "inprogress").length,
+          inreview: list.filter((t) => t.status === "inreview").length,
+          done: list.filter((t) => t.status === "done").length,
+          blocked: list.filter((t) => t.status === "blocked").length,
+          total: list.length,
+        };
+      }
+
+      sendJson(res, 200, { ok: true, stats });
+    } catch (err) {
+      console.error(`${TAG} taskStats error:`, err.message);
+      sendJson(res, 500, { error: `Failed to get stats: ${err.message}` });
+    }
+  }
+
+  async _handleImportTasks(body, res) {
+    if (!this._taskStore) {
+      sendJson(res, 503, { error: "Task store not configured" });
+      return;
+    }
+
+    const tasks = body.tasks || body.backlog || (Array.isArray(body) ? body : null);
+    if (!tasks || !Array.isArray(tasks)) {
+      sendJson(res, 400, { error: "Body must contain 'tasks' array" });
+      return;
+    }
+
+    const results = { created: [], failed: [] };
+    for (const t of tasks) {
+      try {
+        // Recursively use our create handler logic
+        let fullDescription = t.description || "";
+        if (t.implementation_steps?.length || t.acceptance_criteria?.length || t.verification?.length) {
+          const parts = [fullDescription];
+          if (t.implementation_steps?.length) {
+            parts.push("", "## Implementation Steps");
+            for (const step of t.implementation_steps) parts.push(`- ${step}`);
+          }
+          if (t.acceptance_criteria?.length) {
+            parts.push("", "## Acceptance Criteria");
+            for (const c of t.acceptance_criteria) parts.push(`- ${c}`);
+          }
+          if (t.verification?.length) {
+            parts.push("", "## Verification");
+            for (const v of t.verification) parts.push(`- ${v}`);
+          }
+          fullDescription = parts.join("\n");
+        }
+
+        let task;
+        if (typeof this._taskStore.createTask === "function") {
+          task = await this._taskStore.createTask(null, {
+            title: t.title,
+            description: fullDescription,
+            status: t.status || "draft",
+            priority: t.priority || "medium",
+            tags: t.tags || [],
+            baseBranch: t.baseBranch || t.base_branch || "main",
+            workspace: t.workspace || "",
+            repository: t.repository || "",
+            draft: t.draft ?? true,
+          });
+        } else if (typeof this._taskStore.addTask === "function") {
+          task = this._taskStore.addTask({
+            id: randomUUID(),
+            title: t.title,
+            description: fullDescription,
+            status: t.status || "draft",
+            priority: t.priority || "medium",
+            tags: t.tags || [],
+            baseBranch: t.baseBranch || t.base_branch || "main",
+            workspace: t.workspace || "",
+            repository: t.repository || "",
+            draft: t.draft ?? true,
+          });
+        }
+
+        if (task) {
+          results.created.push({ id: task.id, title: task.title });
+        } else {
+          results.failed.push({ title: t.title, error: "addTask returned null" });
+        }
+      } catch (err) {
+        results.failed.push({ title: t.title || "untitled", error: err.message });
+      }
+    }
+
+    console.log(`${TAG} Import: ${results.created.length} created, ${results.failed.length} failed`);
+    sendJson(res, 200, {
+      ok: true,
+      created: results.created.length,
+      failed: results.failed.length,
+      results,
+    });
+  }
+
   async _handleError(taskId, body, res) {
     const { error: errorMsg, pattern, output } = body;
 

package/agent-pool.mjs

@@ -42,14 +42,26 @@
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadConfig } from "./config.mjs";
-import { resolveRepoRoot } from "./repo-root.mjs";
+import { resolveRepoRoot, resolveAgentRepoRoot } from "./repo-root.mjs";
 import { resolveCodexProfileRuntime } from "./codex-model-profiles.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-/** Repository root for the active workspace */
-const REPO_ROOT = resolveRepoRoot();
+/**
+ * Repository root for the active workspace.
+ * Uses lazy resolution so workspace config changes are picked up per-call.
+ * Prefers workspace-aware agent root over raw REPO_ROOT.
+ */
+let _cachedRepoRoot = null;
+function getAgentRepoRoot() {
+  if (!_cachedRepoRoot) {
+    _cachedRepoRoot = resolveAgentRepoRoot();
+  }
+  return _cachedRepoRoot;
+}
+/** @deprecated Use getAgentRepoRoot() — kept for backward compat */
+const REPO_ROOT = resolveAgentRepoRoot();
 
 /** Default timeout: 6 hours — agents should run until the stream-based watchdog detects real issues */
 const DEFAULT_TIMEOUT_MS = 6 * 60 * 60 * 1000;
@@ -102,12 +114,74 @@ function shouldFallbackForSdkError(error) {
   if (!error) return false;
   const message = String(error).toLowerCase();
   if (!message) return false;
+  // SDK not installed / not found
   if (message.includes("not available")) return true;
+  // Missing finish_reason (incomplete response)
   if (message.includes("missing finish_reason")) return true;
   if (message.includes("missing") && message.includes("finish_reason")) return true;
+  // Model-related errors — SDK doesn't support the requested model
+  if (message.includes("not supported")) return true;
+  if (message.includes("model not found")) return true;
+  if (message.includes("model_not_found")) return true;
+  if (message.includes("does not exist")) return true;
+  if (message.includes("invalid model")) return true;
+  // Auth / key errors — SDK isn't properly configured
+  if (message.includes("unauthorized") || message.includes("401")) return true;
+  if (message.includes("api key") && (message.includes("invalid") || message.includes("missing") || message.includes("required"))) return true;
+  if (message.includes("authentication") && (message.includes("failed") || message.includes("required") || message.includes("error"))) return true;
+  if (message.includes("forbidden") || message.includes("403")) return true;
+  // Connection errors — SDK endpoint is unreachable
+  if (message.includes("econnrefused")) return true;
+  if (message.includes("enotfound")) return true;
+  if (message.includes("connection refused")) return true;
   return false;
 }
 
+/**
+ * Check whether an SDK has the minimum prerequisites to be attempted.
+ * This prevents wasting time and error logs trying unconfigured SDKs.
+ *
+ * @param {string} name  SDK canonical name
+ * @returns {{ ok: boolean, reason: string|null }}
+ */
+function hasSdkPrerequisites(name) {
+  // Test mocks bypass prerequisite checks
+  if (process.env[`__MOCK_${name.toUpperCase()}_AVAILABLE`] === "1") {
+    return { ok: true, reason: null };
+  }
+
+  if (name === "codex") {
+    // Codex needs an OpenAI API key (or Azure key, or profile-specific key)
+    const hasKey =
+      process.env.OPENAI_API_KEY ||
+      process.env.AZURE_OPENAI_API_KEY ||
+      process.env.CODEX_MODEL_PROFILE_XL_API_KEY ||
+      process.env.CODEX_MODEL_PROFILE_M_API_KEY;
+    if (!hasKey) {
+      return { ok: false, reason: "no API key (OPENAI_API_KEY / AZURE_OPENAI_API_KEY)" };
+    }
+    return { ok: true, reason: null };
+  }
+  if (name === "copilot") {
+    // Copilot needs either a token or VS Code context
+    const hasToken = process.env.COPILOT_CLI_TOKEN || process.env.GITHUB_TOKEN;
+    // Copilot also works from VS Code extension context — check for common indicators
+    const hasVsCode = process.env.VSCODE_PID || process.env.COPILOT_AGENT_HOST;
+    if (!hasToken && !hasVsCode) {
+      return { ok: false, reason: "no COPILOT_CLI_TOKEN or GITHUB_TOKEN" };
+    }
+    return { ok: true, reason: null };
+  }
+  if (name === "claude") {
+    const hasKey = process.env.ANTHROPIC_API_KEY;
+    if (!hasKey) {
+      return { ok: false, reason: "no ANTHROPIC_API_KEY" };
+    }
+    return { ok: true, reason: null };
+  }
+  return { ok: true, reason: null };
+}
+
 /**
  * Detect if an error is a context/token overflow that should trigger a
  * new thread instead of retrying on the same (exhausted) session.
@@ -1452,18 +1526,25 @@ export async function launchEphemeralThread(
 
   // ── Try primary SDK ──────────────────────────────────────────────────────
   if (primaryAdapter && !isDisabled(primaryName)) {
-    const launcher = await primaryAdapter.load();
-    const result = await launcher(prompt, cwd, timeoutMs, extra);
+    const prereq = hasSdkPrerequisites(primaryName);
+    if (!prereq.ok) {
+      console.warn(
+        `${TAG} primary SDK "${primaryName}" missing prerequisites: ${prereq.reason}; trying fallback chain`,
+      );
+    } else {
+      const launcher = await primaryAdapter.load();
+      const result = await launcher(prompt, cwd, timeoutMs, extra);
 
-    // If it succeeded, or if the error isn't "not available", return as-is
-    if (result.success || !shouldFallbackForSdkError(result.error)) {
-      return result;
-    }
+      // If it succeeded, or if the error isn't fallback-worthy, return as-is
+      if (result.success || !shouldFallbackForSdkError(result.error)) {
+        return result;
+      }
 
-    // Primary SDK not installed — fall through to fallback chain
-    console.warn(
-      `${TAG} primary SDK "${primaryName}" failed (${result.error}); trying fallback chain`,
-    );
+      // Primary SDK not installed — fall through to fallback chain
+      console.warn(
+        `${TAG} primary SDK "${primaryName}" failed (${result.error}); trying fallback chain`,
+      );
+    }
   }
 
   // ── Fallback chain ───────────────────────────────────────────────────────
@@ -1474,6 +1555,15 @@ export async function launchEphemeralThread(
     const adapter = SDK_ADAPTERS[name];
     if (!adapter) continue;
 
+    // Check prerequisites before wasting time trying an unconfigured SDK
+    const prereq = hasSdkPrerequisites(name);
+    if (!prereq.ok) {
+      console.log(
+        `${TAG} skipping fallback SDK "${name}": ${prereq.reason}`,
+      );
+      continue;
+    }
+
     console.log(`${TAG} trying fallback SDK: ${name}`);
     const launcher = await adapter.load();
     const result = await launcher(prompt, cwd, timeoutMs, extra);
@@ -1485,11 +1575,23 @@ export async function launchEphemeralThread(
 
   // ── All SDKs exhausted ───────────────────────────────────────────────────
   const triedSdks = SDK_FALLBACK_ORDER.filter((n) => !isDisabled(n));
+  const configuredSdks = triedSdks.filter((n) => hasSdkPrerequisites(n).ok);
+  const skippedSdks = triedSdks.filter((n) => !hasSdkPrerequisites(n).ok);
+  let errorMsg = `${TAG} no SDK available.`;
+  if (configuredSdks.length > 0) {
+    errorMsg += ` Tried: ${configuredSdks.join(", ")}.`;
+  }
+  if (skippedSdks.length > 0) {
+    errorMsg += ` Skipped (missing credentials): ${skippedSdks.map((n) => `${n} (${hasSdkPrerequisites(n).reason})`).join(", ")}.`;
+  }
+  if (triedSdks.length === 0) {
+    errorMsg += " All SDKs are disabled.";
+  }
   return {
     success: false,
     output: "",
     items: [],
-    error: `${TAG} no SDK available. Tried: ${triedSdks.join(", ") || "(all disabled)"}`,
+    error: errorMsg,
     sdk: primaryName,
     threadId: null,
   };

package/agent-prompts.mjs

@@ -113,6 +113,12 @@ const PROMPT_DEFS = [
     filename: "monitor-restart-loop-fix.md",
     description: "Prompt used when monitor/orchestrator enters restart loops.",
   },
+  {
+    key: "taskManager",
+    filename: "task-manager.md",
+    description:
+      "Task management agent prompt with full CRUD access via CLI and REST API.",
+  },
 ];
 
 export const AGENT_PROMPT_DEFINITIONS = Object.freeze(
@@ -542,6 +548,38 @@ Constraints:
 2. Keep behavior stable and production-safe.
 3. Avoid unrelated refactors.
 4. Prefer small guardrails.
+`,
+  taskManager: `# Bosun Task Manager Agent
+
+You manage the backlog via CLI, REST API, or Node.js API.
+
+## Quick Reference
+
+CLI:
+  bosun task list [--status s] [--json]
+  bosun task create '{"title":"..."}' | --title "..." --priority high
+  bosun task get <id> [--json]
+  bosun task update <id> --status todo --priority critical
+  bosun task delete <id>
+  bosun task stats [--json]
+  bosun task import <file.json>
+  bosun task plan --count N
+
+REST API (port 18432):
+  GET  /api/tasks[?status=todo]
+  GET  /api/tasks/<id>
+  POST /api/tasks/create   {"title":"...","description":"...","priority":"high"}
+  POST /api/tasks/<id>/update  {"status":"todo","priority":"critical"}
+  DELETE /api/tasks/<id>
+  GET  /api/tasks/stats
+  POST /api/tasks/import   {"tasks":[...]}
+
+Task title format: [size] type(scope): description
+Sizes: [xs] [s] [m] [l] [xl]
+Types: feat, fix, docs, refactor, test, chore
+Statuses: draft → todo → inprogress → inreview → done
+
+See .bosun/agents/task-manager.md for full documentation.
 `,
 };
 

package/cli.mjs

@@ -24,7 +24,7 @@ import {
   mkdirSync,
 } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { execFileSync, fork, spawn } from "node:child_process";
+import { execFileSync, execSync, fork, spawn } from "node:child_process";
 import os from "node:os";
 import { createDaemonCrashTracker } from "./daemon-restart-policy.mjs";
 import {
@@ -119,6 +119,16 @@ function showHelp() {
     --workspace-switch <id>     Switch active workspace
     --workspace-add-repo        Add repo to workspace (interactive)
 
+  TASK MANAGEMENT
+    task list [--status s] [--json]  List tasks with optional filters
+    task create <json|flags>    Create a new task from JSON or flags
+    task get <id> [--json]      Show task details by ID (prefix match)
+    task update <id> <patch>    Update task fields (JSON or flags)
+    task delete <id>            Delete a task
+    task stats [--json]         Show aggregate task statistics
+    task import <file.json>     Bulk import tasks from JSON
+    task plan [--count N]       Trigger AI task planner
+
   VIBE-KANBAN
     --no-vk-spawn               Don't auto-spawn Vibe-Kanban
     --vk-ensure-interval <ms>   VK health check interval (default: 60000)
@@ -440,7 +450,27 @@ function startDaemon() {
       detached: true,
       stdio: "ignore",
       windowsHide: process.platform === "win32",
-      env: { ...process.env, BOSUN_DAEMON: "1" },
+      env: {
+        ...process.env,
+        BOSUN_DAEMON: "1",
+        // Propagate the bosun package directory so repo-root detection works
+        // even when the daemon child's cwd is not inside a git repo.
+        BOSUN_DIR: process.env.BOSUN_DIR || fileURLToPath(new URL(".", import.meta.url)),
+        // Propagate REPO_ROOT if available; otherwise resolve from cwd before detaching
+        ...(process.env.REPO_ROOT
+          ? {}
+          : (() => {
+              try {
+                const gitRoot = execSync("git rev-parse --show-toplevel", {
+                  encoding: "utf8",
+                  stdio: ["ignore", "pipe", "ignore"],
+                }).trim();
+                return gitRoot ? { REPO_ROOT: gitRoot } : {};
+              } catch {
+                return {};
+              }
+            })()),
+      },
       // Use home dir so spawn never inherits a deleted CWD (e.g. old git worktree)
       cwd: os.homedir(),
     },
@@ -595,6 +625,15 @@ async function main() {
     return;
   }
 
+  // Handle 'task' subcommand — must come before flag-based routing
+  if (args[0] === "task" || args.includes("--task")) {
+    const { runTaskCli } = await import("./task-cli.mjs");
+    // Pass everything after "task" to the task CLI
+    const taskArgs = args[0] === "task" ? args.slice(1) : args.slice(args.indexOf("--task") + 1);
+    await runTaskCli(taskArgs);
+    process.exit(0);
+  }
+
   // Handle --doctor
   if (args.includes("--doctor") || args.includes("doctor")) {
     const { runConfigDoctor, formatConfigDoctorReport } =