@wrongstack/tools 0.281.3 → 0.282.0

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, addDependency, updateTaskAssignment, assignTask, removeTask, moveTask, updateTask, getTask, transferTaskToBoard, copyTaskToBoard, addTask, removeColumn, updateColumn, addColumn, searchKanban, 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,10 +3493,69 @@ 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,449 @@ 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, search, assignment metadata, provider/model/fallback routing hints, success checks, notes, links, and run status updates.",
+  usageHint: "Use this for durable project kanban state. Assign tasks with provider/model/fallback hints before spawning agents; after a subagent starts or finishes, call mark_assignment to record subagentId/runTaskId/status/result.",
+  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",
+          "search_tasks",
+          "add_column",
+          "update_column",
+          "delete_column",
+          "add_task",
+          "copy_task",
+          "transfer_task",
+          "get_task",
+          "update_task",
+          "move_task",
+          "delete_task",
+          "assign_task",
+          "mark_assignment",
+          "add_dependency",
+          "add_check",
+          "update_check",
+          "add_note",
+          "add_link"
+        ]
+      },
+      boardId: { type: "string" },
+      taskId: { 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" },
+      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"]
+      },
+      dependencyTaskId: { 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.");
+    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 "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]
+        });
+        return { ok: true, message: `${tasks.length} task(s) matched.`, tasks };
+      }
+      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 "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 "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_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}`);
+    }
+  }
+};
+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) {
+  return {
+    title: input.title ?? "",
+    columnId: input.columnId,
+    description: input.description,
+    priority: input.priority,
+    status: input.status,
+    labels: input.labels,
+    assignedAgent: input.agentId,
+    ...input.agentId || input.provider || input.model ? { assignment: assignmentForTaskCreate(input) } : {}
+  };
+}
+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
+  };
+}
+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 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 +12749,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 +12833,7 @@ var builtinTools = [
   searchTool,
   todoTool,
   planTool,
+  kanbanTool,
   taskTool,
   gitTool,
   patchTool,