@wrongstack/tools 0.281.3 → 0.282.1

package/dist/pack.js

@@ -1,6 +1,6 @@
 import { spawn, execFileSync } from 'node:child_process';
 import * as Core from '@wrongstack/core';
-import { buildChildEnv, getDesignKitLoader, isDesignStack, loadActiveKit, applyTokenOverrides, setActiveKit, recordKitChoice, recordOverrides, setDesignOverrides, materializeTokens, runDesignVerify, ToolValidationError, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, ToolError, FetchError, isPrivateIPv4, isPrivateIPv6, assessCommitSafety, compileGlob, expectDefined, recordPackageAction, detectPackageEcosystem, deepMerge, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, mutateTasks, formatTaskList, formatPlan, FsError, toErrorMessage as toErrorMessage$2, computeTaskItemProgress, loadPlan, savePlan, loadTasks, saveTasks, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
+import { buildChildEnv, getDesignKitLoader, isDesignStack, loadActiveKit, applyTokenOverrides, setActiveKit, recordKitChoice, recordOverrides, setDesignOverrides, materializeTokens, runDesignVerify, ToolValidationError, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, ToolError, FetchError, isPrivateIPv4, isPrivateIPv6, assessCommitSafety, compileGlob, expectDefined, recordPackageAction, detectPackageEcosystem, deepMerge, addLinkToTask, addNoteToTask, updateCheckOnTask, addCheckToTask, updateGoalMetricOnTask, addGoalMetricToTask, addDependency, updateTaskAssignment, assignTask, releaseTaskClaim, claimReadyTask, getTaskChain, setTaskChain, removeTask, moveTask, updateTask, getTask, transferTaskToBoard, copyTaskToBoard, mergeTasks, splitTask, addTask, removeColumn, updateColumn, addColumn, getKanbanOrchestrationSnapshot, listReadyTasks, searchKanban, deserializeTaskGraph, syncBoardFromTaskGraph, exportBoardToTaskGraph, serializeTaskGraph, exportBoardAsMarkdown, generateBoardFromDescription, createBoard, parseLinesIntoTasks, getBoard, removeBoard, duplicateBoard, updateBoard, listBoards, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, mutateTasks, formatTaskList, formatPlan, FsError, toErrorMessage as toErrorMessage$2, computeTaskItemProgress, loadPlan, savePlan, loadTasks, saveTasks, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
 import * as fs from 'node:fs';
 import { statSync, mkdirSync, createWriteStream } from 'node:fs';
 import * as fs2 from 'node:fs/promises';
@@ -345,14 +345,34 @@ function redactCommand(cmd) {
   return result;
 }
 var DEFAULT_GRACE_MS = 2e3;
-function killWin32Tree(pid) {
+var WIN32_TASKKILL_TIMEOUT_MS = 5e3;
+function killWin32Tree(pid, opts = {}) {
   try {
     const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
       stdio: "ignore",
       windowsHide: true
     });
-    child.on("error", () => {
-    });
+    let settled = false;
+    let timeout;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      try {
+        opts.onSettled?.();
+      } catch {
+      }
+    };
+    child.on("error", settle);
+    child.on("close", settle);
+    timeout = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      settle();
+    }, Math.max(1, opts.timeoutMs ?? WIN32_TASKKILL_TIMEOUT_MS));
+    timeout.unref?.();
     child.unref();
     return true;
   } catch {
@@ -582,17 +602,18 @@ var ProcessRegistryImpl = class {
     const isWin4 = os2.platform() === "win32";
     if (isWin4) {
       const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
-      if (liveRealChild && killWin32Tree(pid)) {
-        const fallback = setTimeout(() => {
-          if (p.child.exitCode === null) {
-            try {
-              p.child.kill("SIGKILL");
-            } catch {
-            }
+      const directFallback = () => {
+        if (p.child.exitCode === null) {
+          try {
+            p.child.kill("SIGKILL");
+          } catch {
           }
-        }, graceMs);
-        fallback.unref?.();
-      } else {
+        }
+      };
+      if (liveRealChild && killWin32Tree(pid, {
+        timeoutMs: Math.max(graceMs, WIN32_TASKKILL_TIMEOUT_MS),
+        onSettled: directFallback
+      })) ; else {
         try {
           p.child.kill(force ? "SIGKILL" : "SIGTERM");
         } catch {
@@ -2088,17 +2109,14 @@ var bashTool = {
     const spool = createOutputSpool({ tool: "bash", thresholdBytes: MAX_OUTPUT });
     function killWithTimeout(child2, timeoutMs2) {
       if (isWin4) {
-        if (typeof child2.pid === "number" && child2.exitCode === null && killWin32Tree(child2.pid)) {
-          const fallback = setTimeout(() => {
-            if (child2.exitCode === null) {
-              try {
-                child2.kill();
-              } catch {
-              }
+        if (typeof child2.pid === "number" && child2.exitCode === null) {
+          const attempted = registry.kill(child2.pid, { force: true, graceMs: timeoutMs2 });
+          if (!attempted) {
+            try {
+              child2.kill();
+            } catch {
             }
-          }, 2e3);
-          timers.push(fallback);
-          fallback.unref?.();
+          }
         } else {
           try {
             child2.kill();
@@ -3475,11 +3493,70 @@ function detectLang(file) {
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
-    return await syncGoParse(file, content, lang);
+    const parsed = await syncGoParse(file, content, lang);
+    if (parsed.symbols.length > 0) {
+      return parsed;
+    }
+    return fallbackParse(file, content, lang);
   } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
+    return fallbackParse(file, content, lang);
   }
 }
+function fallbackParse(filePath, content, lang) {
+  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(content) || hasUnbalancedDelimiters(content)) {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  const packageName = content.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
+  const lines = content.split(/\r?\n/);
+  for (const [idx, line] of lines.entries()) {
+    const trimmed = line.trimStart();
+    const col = line.length - trimmed.length + 1;
+    const fn = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/.exec(trimmed);
+    if (fn?.[1]) {
+      addFallbackSymbol(symbols, { filePath, lang, kind: trimmed.startsWith("func (") ? "method" : "function", name: fn[1], line: idx + 1, col, signature: trimmed, scope: packageName ? `${packageName}.${fn[1]}` : fn[1] });
+      continue;
+    }
+    const typeDecl = /^type\s+([A-Za-z_]\w*)\b/.exec(trimmed);
+    if (typeDecl?.[1]) {
+      addFallbackSymbol(symbols, { filePath, lang, kind: "type", name: typeDecl[1], line: idx + 1, col, signature: trimmed, scope: packageName });
+      continue;
+    }
+    const valueDecl = /^(const|var)\s+([A-Za-z_]\w*)\b/.exec(trimmed);
+    if (valueDecl?.[1] && valueDecl[2]) {
+      addFallbackSymbol(symbols, { filePath, lang, kind: valueDecl[1], name: valueDecl[2], line: idx + 1, col, signature: trimmed, scope: packageName });
+    }
+  }
+  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+}
+function addFallbackSymbol(symbols, opts) {
+  symbols.push({
+    id: 0,
+    lang: opts.lang,
+    kind: opts.kind,
+    name: opts.name,
+    file: opts.filePath,
+    line: opts.line,
+    col: opts.col,
+    signature: opts.signature,
+    docComment: "",
+    scope: opts.scope,
+    text: `${opts.name} ${opts.signature}`.trim()
+  });
+}
+function hasUnbalancedDelimiters(content) {
+  const pairs = { "(": ")", "[": "]", "{": "}" };
+  const closers = new Set(Object.values(pairs));
+  const stack = [];
+  for (const ch of content) {
+    if (pairs[ch]) {
+      stack.push(pairs[ch]);
+    } else if (closers.has(ch) && stack.pop() !== ch) {
+      return true;
+    }
+  }
+  return stack.length > 0;
+}
 var GO_PARSE_SCRIPT = `
 package main
 
@@ -9206,6 +9283,700 @@ function toYaml(data, indent = 0) {
   }
   return String(data) + "\n";
 }
+var kanbanTool = {
+  name: "kanban",
+  category: "Project",
+  description: "Manage project-scoped multi-kanban boards stored under .wrongstack/kanbans. Supports board/task/column CRUD, ready-task queues, dependency chains, split/merge, assignment metadata, provider/model/fallback routing hints, goal metrics, success checks, notes, links, and run status updates.",
+  usageHint: "Use this for durable project kanban state. Agents should call snapshot/ready_tasks, then claim_task before working. Use set_chain for ordered work, split_task/merge_tasks when task scope changes, assign_task with provider/model/fallback hints before spawning, mark_assignment when starting or finishing, and release_task if the claim cannot be worked.",
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "task",
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: [
+          "list_boards",
+          "get_board",
+          "create_board",
+          "duplicate_board",
+          "update_board",
+          "delete_board",
+          "generate_board",
+          "export_markdown",
+          "export_task_graph",
+          "sync_task_graph",
+          "search_tasks",
+          "ready_tasks",
+          "snapshot",
+          "add_column",
+          "update_column",
+          "delete_column",
+          "add_task",
+          "split_task",
+          "merge_tasks",
+          "copy_task",
+          "transfer_task",
+          "get_task",
+          "update_task",
+          "move_task",
+          "delete_task",
+          "set_chain",
+          "get_chain",
+          "claim_task",
+          "release_task",
+          "assign_task",
+          "mark_assignment",
+          "add_dependency",
+          "add_goal_metric",
+          "update_goal_metric",
+          "add_check",
+          "update_check",
+          "add_note",
+          "add_link"
+        ]
+      },
+      boardId: { type: "string" },
+      taskId: { type: "string" },
+      taskIds: { type: "array", items: { type: "string" } },
+      chainId: { type: "string" },
+      columnId: { type: "string" },
+      targetBoardId: { type: "string" },
+      targetColumnId: { type: "string" },
+      title: { type: "string" },
+      description: { type: "string" },
+      tags: { type: "array", items: { type: "string" } },
+      labels: { type: "array", items: { type: "string" } },
+      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+      status: {
+        type: "string",
+        enum: [
+          "pending",
+          "ready",
+          "in_progress",
+          "blocked",
+          "review",
+          "completed",
+          "failed",
+          "archived"
+        ]
+      },
+      order: { type: "number" },
+      query: { type: "string" },
+      limit: { type: "number" },
+      agentId: { type: "string" },
+      name: { type: "string" },
+      role: { type: "string" },
+      provider: { type: "string" },
+      model: { type: "string" },
+      fallbackProfile: { type: "string" },
+      fallbackModels: { type: "array", items: { type: "string" } },
+      tools: { type: "array", items: { type: "string" } },
+      allowedCapabilities: { type: "array", items: { type: "string" } },
+      subagentId: { type: "string" },
+      runTaskId: { type: "string" },
+      lastResult: { type: "string" },
+      error: { type: "string" },
+      assignmentStatus: {
+        type: "string",
+        enum: ["assigned", "queued", "running", "completed", "failed", "cancelled"]
+      },
+      releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
+      releaseReason: { type: "string" },
+      clearAssignee: { type: "boolean" },
+      taskGraph: { type: "object" },
+      graphId: { type: "string" },
+      specId: { type: "string" },
+      sourceSystem: { type: "string" },
+      phaseId: { type: "string" },
+      preserveOriginTaskIds: { type: "boolean" },
+      includeArchived: { type: "boolean" },
+      archiveMissingTasks: { type: "boolean" },
+      preserveManualDependencies: { type: "boolean" },
+      dependencyTaskId: { type: "string" },
+      enforceDependencies: { type: "boolean" },
+      childTitles: { type: "array", items: { type: "string" } },
+      inheritAssignment: { type: "boolean" },
+      inheritLabels: { type: "boolean" },
+      inheritSuccessCriteria: { type: "boolean" },
+      inheritGoalMetrics: { type: "boolean" },
+      inheritDependencies: { type: "boolean" },
+      chainChildren: { type: "boolean" },
+      rewireDependents: { type: "boolean" },
+      closeSourceTasks: { type: "boolean" },
+      metricId: { type: "string" },
+      metricName: { type: "string" },
+      metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
+      metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+      metricUnit: { type: "string" },
+      metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
+      metricNotes: { type: "string" },
+      checkId: { type: "string" },
+      checkDescription: { type: "string" },
+      checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
+      note: { type: "string" },
+      author: { type: "string" },
+      url: { type: "string" },
+      linkTitle: { type: "string" },
+      linkType: {
+        type: "string",
+        enum: ["issue", "pr", "doc", "commit", "design", "file", "url", "other"]
+      },
+      context: { type: "string" },
+      columns: { type: "array", items: { type: "string" } },
+      generatedBy: { type: "string" },
+      includeTasks: { type: "boolean" },
+      includeCompletedTasks: { type: "boolean" },
+      preserveAssignment: { type: "boolean" },
+      preserveDependencies: { type: "boolean" },
+      moveTasksToColumnId: { type: "string" }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const projectRoot = ctx.projectRoot;
+    if (!projectRoot) return fail("No project root is available.");
+    try {
+      switch (input.action) {
+        case "list_boards": {
+          const boards = await listBoards(projectRoot);
+          return { ok: true, message: `${boards.length} board(s).`, boards };
+        }
+        case "get_board": {
+          const board = await requireBoard(projectRoot, input.boardId);
+          return board ? okBoard(board) : fail("Board not found.");
+        }
+        case "create_board": {
+          if (!input.title) return fail("create_board requires title.");
+          const board = await createBoard(projectRoot, {
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {}
+          });
+          return { ok: true, message: `Board created: ${board.title}`, board };
+        }
+        case "update_board": {
+          if (!input.boardId) return fail("update_board requires boardId.");
+          const board = await updateBoard(projectRoot, input.boardId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {}
+          });
+          return board ? okBoard(board, "Board updated.") : fail("Board not found.");
+        }
+        case "duplicate_board": {
+          if (!input.boardId) return fail("duplicate_board requires boardId.");
+          const board = await duplicateBoard(projectRoot, input.boardId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+            ...input.includeTasks !== void 0 ? { includeTasks: input.includeTasks } : {},
+            ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+            ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {}
+          });
+          return board ? okBoard(board, "Board duplicated.") : fail("Board not found.");
+        }
+        case "delete_board": {
+          if (!input.boardId) return fail("delete_board requires boardId.");
+          const removed = await removeBoard(projectRoot, input.boardId);
+          return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
+        }
+        case "generate_board": {
+          if (!input.description) return fail("generate_board requires description.");
+          const boardInput = generateBoardFromDescription({
+            description: input.description,
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.context !== void 0 ? { context: input.context } : {},
+            ...input.columns !== void 0 ? { columns: input.columns } : {}
+          });
+          const board = await createBoard(projectRoot, boardInput);
+          for (const taskInput2 of parseLinesIntoTasks(
+            input.description,
+            board.columns[0]?.id ?? "backlog"
+          )) {
+            await addTask(projectRoot, board.id, taskInput2);
+          }
+          return okBoard(await getBoard(projectRoot, board.id) ?? board, "Board generated.");
+        }
+        case "export_markdown": {
+          const board = await requireBoard(projectRoot, input.boardId);
+          if (!board) return fail("Board not found.");
+          return {
+            ok: true,
+            message: "Board exported.",
+            board,
+            markdown: exportBoardAsMarkdown(board)
+          };
+        }
+        case "export_task_graph": {
+          if (!input.boardId) return fail("export_task_graph requires boardId.");
+          const exported = await exportBoardToTaskGraph(projectRoot, input.boardId, {
+            ...input.graphId !== void 0 ? { graphId: input.graphId } : {},
+            ...input.specId !== void 0 ? { specId: input.specId } : {},
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.preserveOriginTaskIds !== void 0 ? { preserveOriginTaskIds: input.preserveOriginTaskIds } : {},
+            ...input.includeArchived !== void 0 ? { includeArchived: input.includeArchived } : {}
+          });
+          if (!exported) return fail("Board not found.");
+          return {
+            ok: true,
+            message: `Task graph exported with ${exported.graph.nodes.size} node(s).`,
+            board: exported.board,
+            taskGraph: serializeTaskGraph(exported.graph)
+          };
+        }
+        case "sync_task_graph": {
+          if (!input.boardId || !input.taskGraph) {
+            return fail("sync_task_graph requires boardId and taskGraph.");
+          }
+          const graph = deserializeTaskGraph(input.taskGraph);
+          const result = await syncBoardFromTaskGraph(projectRoot, input.boardId, graph, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {},
+            ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+            ...input.sourceSystem !== void 0 ? { sourceSystem: input.sourceSystem } : {},
+            ...input.phaseId !== void 0 ? { phaseId: input.phaseId } : {},
+            ...input.includeCompletedTasks !== void 0 ? { includeCompletedTasks: input.includeCompletedTasks } : {},
+            ...input.archiveMissingTasks !== void 0 ? { archiveMissingTasks: input.archiveMissingTasks } : {},
+            ...input.preserveManualDependencies !== void 0 ? { preserveManualDependencies: input.preserveManualDependencies } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `Task graph synced: ${result.createdTaskIds.length} created, ${result.updatedTaskIds.length} updated, ${result.archivedTaskIds.length} archived.`,
+            board: result.board
+          } : fail("Board not found.");
+        }
+        case "search_tasks": {
+          const tasks = await searchKanban(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            status: input.status,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId
+          });
+          return { ok: true, message: `${tasks.length} task(s) matched.`, tasks };
+        }
+        case "ready_tasks": {
+          const tasks = await listReadyTasks(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId,
+            limit: input.limit
+          });
+          return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
+        }
+        case "snapshot": {
+          const snapshot = await getKanbanOrchestrationSnapshot(projectRoot, {
+            query: input.query,
+            boardId: input.boardId,
+            assignedAgent: input.agentId,
+            status: input.status,
+            priority: input.priority,
+            label: input.labels?.[0],
+            chainId: input.chainId
+          });
+          return {
+            ok: true,
+            message: `${snapshot.ready.length} ready, ${snapshot.running.length} running, ${snapshot.blocked.length} blocked.`,
+            snapshot
+          };
+        }
+        case "add_column": {
+          if (!input.boardId || !input.title) return fail("add_column requires boardId and title.");
+          const result = await addColumn(projectRoot, input.boardId, {
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {}
+          });
+          return result ? okBoard(result.board, "Column added.") : fail("Board not found.");
+        }
+        case "update_column": {
+          if (!input.boardId || !input.columnId)
+            return fail("update_column requires boardId and columnId.");
+          const board = await updateColumn(projectRoot, input.boardId, input.columnId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.order !== void 0 ? { order: input.order } : {}
+          });
+          return board ? okBoard(board, "Column updated.") : fail("Column not found.");
+        }
+        case "delete_column": {
+          if (!input.boardId || !input.columnId)
+            return fail("delete_column requires boardId and columnId.");
+          const board = await removeColumn(projectRoot, input.boardId, input.columnId, {
+            moveTasksToColumnId: input.moveTasksToColumnId
+          });
+          return board ? okBoard(board, "Column deleted.") : fail("Column not found.");
+        }
+        case "add_task": {
+          if (!input.boardId || !input.title) return fail("add_task requires boardId and title.");
+          const result = await addTask(projectRoot, input.boardId, taskInput(input));
+          return result ? okTask(result.board, result.task, "Task added.") : fail("Board not found.");
+        }
+        case "split_task": {
+          if (!input.boardId || !input.taskId || !input.childTitles?.length) {
+            return fail("split_task requires boardId, taskId, and childTitles.");
+          }
+          const result = await splitTask(projectRoot, input.boardId, input.taskId, {
+            titles: input.childTitles,
+            ...input.targetColumnId !== void 0 ? { columnId: input.targetColumnId } : {},
+            ...input.inheritAssignment !== void 0 ? { inheritAssignment: input.inheritAssignment } : {},
+            ...input.inheritLabels !== void 0 ? { inheritLabels: input.inheritLabels } : {},
+            ...input.inheritSuccessCriteria !== void 0 ? { inheritSuccessCriteria: input.inheritSuccessCriteria } : {},
+            ...input.inheritGoalMetrics !== void 0 ? { inheritGoalMetrics: input.inheritGoalMetrics } : {},
+            ...input.inheritDependencies !== void 0 ? { inheritDependencies: input.inheritDependencies } : {},
+            ...input.chainChildren !== void 0 ? { chainChildren: input.chainChildren } : {},
+            ...input.rewireDependents !== void 0 ? { rewireDependents: input.rewireDependents } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `${result.children.length} child task(s) created.`,
+            board: result.board,
+            task: result.parent,
+            children: result.children
+          } : fail("Task not found.");
+        }
+        case "merge_tasks": {
+          if (!input.boardId || !input.taskIds?.length || !input.title) {
+            return fail("merge_tasks requires boardId, taskIds, and title.");
+          }
+          const result = await mergeTasks(projectRoot, input.boardId, {
+            taskIds: input.taskIds,
+            title: input.title,
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+            ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+            ...input.closeSourceTasks !== void 0 ? { closeSourceTasks: input.closeSourceTasks } : {}
+          });
+          return result ? okTask(result.board, result.task, "Tasks merged.") : fail("Board or task not found.");
+        }
+        case "copy_task": {
+          if (!input.boardId || !input.taskId || !input.targetBoardId) {
+            return fail("copy_task requires boardId, taskId, and targetBoardId.");
+          }
+          const result = await copyTaskToBoard(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetBoardId,
+            {
+              ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+              ...input.order !== void 0 ? { targetOrder: input.order } : {},
+              ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+              ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
+            }
+          );
+          return result ? okTask(result.targetBoard, result.task, "Task copied to target board.") : fail("Board or task not found.");
+        }
+        case "transfer_task": {
+          if (!input.boardId || !input.taskId || !input.targetBoardId) {
+            return fail("transfer_task requires boardId, taskId, and targetBoardId.");
+          }
+          const result = await transferTaskToBoard(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetBoardId,
+            {
+              ...input.targetColumnId !== void 0 ? { targetColumnId: input.targetColumnId } : {},
+              ...input.order !== void 0 ? { targetOrder: input.order } : {},
+              ...input.preserveAssignment !== void 0 ? { preserveAssignment: input.preserveAssignment } : {},
+              ...input.preserveDependencies !== void 0 ? { preserveDependencies: input.preserveDependencies } : {}
+            }
+          );
+          return result ? okTask(result.targetBoard, result.task, "Task transferred to target board.") : fail("Board or task not found.");
+        }
+        case "get_task": {
+          if (!input.boardId || !input.taskId) return fail("get_task requires boardId and taskId.");
+          const task = await getTask(projectRoot, input.boardId, input.taskId);
+          return task ? { ok: true, message: "Task loaded.", task } : fail("Task not found.");
+        }
+        case "update_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("update_task requires boardId and taskId.");
+          const board = await updateTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            taskPatch(input)
+          );
+          return board ? okBoard(board, "Task updated.") : fail("Task not found.");
+        }
+        case "move_task": {
+          if (!input.boardId || !input.taskId || !input.targetColumnId) {
+            return fail("move_task requires boardId, taskId, and targetColumnId.");
+          }
+          const board = await moveTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.targetColumnId,
+            input.order
+          );
+          return board ? okBoard(board, "Task moved.") : fail("Move failed.");
+        }
+        case "delete_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("delete_task requires boardId and taskId.");
+          const board = await removeTask(projectRoot, input.boardId, input.taskId);
+          return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
+        }
+        case "set_chain": {
+          if (!input.boardId || !input.taskIds?.length) {
+            return fail("set_chain requires boardId and taskIds.");
+          }
+          const result = await setTaskChain(projectRoot, input.boardId, {
+            taskIds: input.taskIds,
+            ...input.chainId !== void 0 ? { chainId: input.chainId } : {},
+            ...input.enforceDependencies !== void 0 ? { enforceDependencies: input.enforceDependencies } : {}
+          });
+          return result ? {
+            ok: true,
+            message: `Chain set: ${result.chainId}`,
+            board: result.board,
+            chain: result.tasks
+          } : fail("Board or task not found.");
+        }
+        case "get_chain": {
+          if (!input.boardId || !(input.taskId || input.chainId)) {
+            return fail("get_chain requires boardId and taskId or chainId.");
+          }
+          const result = await getTaskChain(
+            projectRoot,
+            input.boardId,
+            input.taskId ?? input.chainId ?? ""
+          );
+          return result ? {
+            ok: true,
+            message: `Chain loaded: ${result.chainId}`,
+            board: result.board,
+            chain: result.tasks
+          } : fail("Chain not found.");
+        }
+        case "claim_task": {
+          const result = await claimReadyTask(projectRoot, {
+            ...input.boardId !== void 0 ? { boardId: input.boardId } : {},
+            ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
+            ...assignmentInput(input),
+            status: input.assignmentStatus ?? "queued"
+          });
+          return result ? okTask(result.board, result.task, "Task claimed.") : fail("No ready kanban task matched the claim.");
+        }
+        case "release_task": {
+          if (!input.boardId || !input.taskId) {
+            return fail("release_task requires boardId and taskId.");
+          }
+          const board = await releaseTaskClaim(projectRoot, input.boardId, input.taskId, {
+            ...input.releaseStatus !== void 0 ? { status: input.releaseStatus } : {},
+            ...input.releaseReason !== void 0 ? { reason: input.releaseReason } : {},
+            ...input.clearAssignee !== void 0 ? { clearAssignee: input.clearAssignee } : {}
+          });
+          return board ? okBoard(board, "Task claim released.") : fail("Task not found.");
+        }
+        case "assign_task": {
+          if (!input.boardId || !input.taskId)
+            return fail("assign_task requires boardId and taskId.");
+          const board = await assignTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            assignmentInput(input)
+          );
+          return board ? okBoard(board, "Task assigned.") : fail("Task not found.");
+        }
+        case "mark_assignment": {
+          if (!input.boardId || !input.taskId)
+            return fail("mark_assignment requires boardId and taskId.");
+          const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
+          const board = await updateTaskAssignment(projectRoot, input.boardId, input.taskId, {
+            ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
+            ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
+            ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
+            ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
+            ...input.error !== void 0 ? { error: input.error } : {},
+            ...input.agentId !== void 0 ? { agentId: input.agentId } : {}
+          });
+          return board ? okBoard(board, "Assignment updated.") : fail("Task not found.");
+        }
+        case "add_dependency": {
+          if (!input.boardId || !input.taskId || !input.dependencyTaskId) {
+            return fail("add_dependency requires boardId, taskId, and dependencyTaskId.");
+          }
+          const board = await addDependency(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.dependencyTaskId
+          );
+          return board ? okBoard(board, "Dependency added.") : fail("Task not found.");
+        }
+        case "add_goal_metric": {
+          if (!input.boardId || !input.taskId || !input.metricName) {
+            return fail("add_goal_metric requires boardId, taskId, and metricName.");
+          }
+          const board = await addGoalMetricToTask(projectRoot, input.boardId, input.taskId, {
+            name: input.metricName,
+            ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+            ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+            ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+            ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+            ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+          });
+          return board ? okBoard(board, "Goal metric added.") : fail("Task not found.");
+        }
+        case "update_goal_metric": {
+          if (!input.boardId || !input.taskId || !input.metricId) {
+            return fail("update_goal_metric requires boardId, taskId, and metricId.");
+          }
+          const board = await updateGoalMetricOnTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.metricId,
+            {
+              ...input.metricName !== void 0 ? { name: input.metricName } : {},
+              ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
+              ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
+              ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+              ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
+              ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
+            }
+          );
+          return board ? okBoard(board, "Goal metric updated.") : fail("Metric not found.");
+        }
+        case "add_check": {
+          if (!input.boardId || !input.taskId || !input.checkDescription) {
+            return fail("add_check requires boardId, taskId, and checkDescription.");
+          }
+          const board = await addCheckToTask(projectRoot, input.boardId, input.taskId, {
+            description: input.checkDescription,
+            type: "manual",
+            status: input.checkStatus
+          });
+          return board ? okBoard(board, "Check added.") : fail("Task not found.");
+        }
+        case "update_check": {
+          if (!input.boardId || !input.taskId || !input.checkId) {
+            return fail("update_check requires boardId, taskId, and checkId.");
+          }
+          const board = await updateCheckOnTask(
+            projectRoot,
+            input.boardId,
+            input.taskId,
+            input.checkId,
+            {
+              ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
+              ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {}
+            }
+          );
+          return board ? okBoard(board, "Check updated.") : fail("Check not found.");
+        }
+        case "add_note": {
+          if (!input.boardId || !input.taskId || !input.note)
+            return fail("add_note requires boardId, taskId, and note.");
+          const board = await addNoteToTask(projectRoot, input.boardId, input.taskId, {
+            author: input.author ?? "agent",
+            content: input.note
+          });
+          return board ? okBoard(board, "Note added.") : fail("Task not found.");
+        }
+        case "add_link": {
+          if (!input.boardId || !input.taskId || !input.url)
+            return fail("add_link requires boardId, taskId, and url.");
+          const board = await addLinkToTask(projectRoot, input.boardId, input.taskId, {
+            url: input.url,
+            type: input.linkType ?? "url",
+            ...input.linkTitle !== void 0 ? { title: input.linkTitle } : {}
+          });
+          return board ? okBoard(board, "Link added.") : fail("Task not found.");
+        }
+        default:
+          return fail(`Unknown kanban action: ${input.action}`);
+      }
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  }
+};
+function fail(message) {
+  return { ok: false, message };
+}
+function okBoard(board, message = "Board loaded.") {
+  return { ok: true, message, board };
+}
+function okTask(board, task, message) {
+  return { ok: true, message, board, task };
+}
+async function requireBoard(projectRoot, boardId) {
+  return boardId ? getBoard(projectRoot, boardId) : null;
+}
+function taskInput(input) {
+  const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
+  return {
+    title: input.title ?? "",
+    columnId: input.columnId,
+    description: input.description,
+    priority: input.priority,
+    status: input.status,
+    labels: input.labels,
+    ...assignment?.agentId ?? assignment?.role ?? assignment?.name ? { assignedAgent: assignment.agentId ?? assignment.role ?? assignment.name } : {},
+    ...input.assignee ?? assignment?.name ?? assignment?.agentId ? { assignee: input.assignee ?? assignment?.name ?? assignment?.agentId } : {},
+    ...input.dependencyTaskId !== void 0 ? { dependsOn: [input.dependencyTaskId] } : {},
+    ...assignment ? { assignment } : {}
+  };
+}
+function taskPatch(input) {
+  return {
+    title: input.title,
+    description: input.description,
+    columnId: input.columnId,
+    order: input.order,
+    priority: input.priority,
+    status: input.status,
+    labels: input.labels,
+    assignedAgent: input.agentId,
+    ...input.dependencyTaskId !== void 0 ? { dependsOn: [input.dependencyTaskId] } : {}
+  };
+}
+function assignmentInput(input) {
+  return {
+    agentId: input.agentId,
+    name: input.name,
+    role: input.role,
+    provider: input.provider,
+    model: input.model,
+    fallbackProfile: input.fallbackProfile,
+    fallbackModels: input.fallbackModels,
+    tools: input.tools,
+    allowedCapabilities: input.allowedCapabilities,
+    assignee: input.assignee
+  };
+}
+function hasAssignmentInput(input) {
+  return input.agentId !== void 0 || input.name !== void 0 || input.role !== void 0 || input.provider !== void 0 || input.model !== void 0 || input.fallbackProfile !== void 0 || input.fallbackModels !== void 0 || input.tools !== void 0 || input.allowedCapabilities !== void 0 || input.assignee !== void 0 || input.assignmentStatus !== void 0;
+}
+function assignmentForTaskCreate(input) {
+  return {
+    status: input.assignmentStatus ?? "assigned",
+    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.role !== void 0 ? { role: input.role } : {},
+    ...input.provider !== void 0 ? { provider: input.provider } : {},
+    ...input.model !== void 0 ? { model: input.model } : {},
+    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
+    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {}
+  };
+}
 
 // src/lint.ts
 var lintTool = {
@@ -12229,56 +13000,75 @@ var writeTool = {
     required: ["path", "content"]
   },
   async execute(input, ctx) {
-    if (!input?.path) {
-      throw new ToolValidationError({
-        message: "write: path is required",
-        field: "path"
-      });
-    }
-    if (input.content === void 0) {
-      throw new ToolValidationError({
-        message: "write: content is required",
-        field: "content"
-      });
-    }
-    const absPath = await safeResolveReal(input.path, ctx);
-    let existed = false;
-    let prev = "";
-    try {
-      const stat12 = await fs2.stat(absPath);
-      existed = stat12.isFile();
-      if (existed) {
-        if (!ctx.hasRead(absPath)) {
-          prev = await fs2.readFile(absPath, "utf8");
-          ctx.recordRead(absPath, stat12.mtimeMs, "write");
-        } else {
-          prev = await fs2.readFile(absPath, "utf8");
-        }
-      }
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        throw err;
+    return writeFile7(input, ctx);
+  },
+  async *executeStream(input, ctx) {
+    const prepared = await prepareWrite(input, ctx);
+    if (!prepared.existed) {
+      for (const line of input.content.split("\n")) {
+        yield { type: "partial_output", text: `${line}
+`, data: { livePreview: true } };
       }
     }
-    await atomicWrite(absPath, input.content);
-    const diff = existed ? unifiedDiff(prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
-+ (new file, ${input.content.split("\n").length} lines)`;
-    const stat11 = await fs2.stat(absPath);
-    ctx.recordRead(absPath, stat11.mtimeMs, "write");
-    ctx.session.recordFileChange({
-      path: absPath,
-      action: existed ? "modified" : "created",
-      before: existed ? prev : null,
-      after: input.content
-    });
-    return {
-      path: absPath,
-      bytes_written: Buffer.byteLength(input.content, "utf8"),
-      created: !existed,
-      diff
-    };
+    yield { type: "final", output: await finishWrite(input, ctx, prepared) };
   }
 };
+async function writeFile7(input, ctx) {
+  return finishWrite(input, ctx, await prepareWrite(input, ctx));
+}
+async function prepareWrite(input, ctx) {
+  if (!input?.path) {
+    throw new ToolValidationError({
+      message: "write: path is required",
+      field: "path"
+    });
+  }
+  if (input.content === void 0) {
+    throw new ToolValidationError({
+      message: "write: content is required",
+      field: "content"
+    });
+  }
+  const absPath = await safeResolveReal(input.path, ctx);
+  let existed = false;
+  let prev = "";
+  try {
+    const stat11 = await fs2.stat(absPath);
+    existed = stat11.isFile();
+    if (existed) {
+      if (!ctx.hasRead(absPath)) {
+        prev = await fs2.readFile(absPath, "utf8");
+        ctx.recordRead(absPath, stat11.mtimeMs, "write");
+      } else {
+        prev = await fs2.readFile(absPath, "utf8");
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return { absPath, existed, prev };
+}
+async function finishWrite(input, ctx, prepared) {
+  await atomicWrite(prepared.absPath, input.content);
+  const diff = prepared.existed ? unifiedDiff(prepared.prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
++ (new file, ${input.content.split("\n").length} lines)`;
+  const stat11 = await fs2.stat(prepared.absPath);
+  ctx.recordRead(prepared.absPath, stat11.mtimeMs, "write");
+  ctx.session.recordFileChange({
+    path: prepared.absPath,
+    action: prepared.existed ? "modified" : "created",
+    before: prepared.existed ? prepared.prev : null,
+    after: input.content
+  });
+  return {
+    path: prepared.absPath,
+    bytes_written: Buffer.byteLength(input.content, "utf8"),
+    created: !prepared.existed,
+    diff
+  };
+}
 
 // src/builtin.ts
 var builtinTools = [
@@ -12294,6 +13084,7 @@ var builtinTools = [
   searchTool,
   todoTool,
   planTool,
+  kanbanTool,
   taskTool,
   gitTool,
   patchTool,