@wrongstack/tools 0.286.0 → 0.287.0

package/dist/pack.js

@@ -6054,6 +6054,9 @@ ${hint}` : ""),
 };
 
 // src/batch-tool-use.ts
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "@wrongstack/core";
 var batchToolUseTool = {
   name: "batch_tool_use",
   category: "Meta",
@@ -6090,7 +6093,7 @@ var batchToolUseTool = {
     },
     required: ["calls"]
   },
-  async execute(input, ctx, opts) {
+  async execute(input, ctx, _opts) {
     if (!input?.calls || input.calls.length === 0) {
       return {
         results: [],
@@ -6100,18 +6103,33 @@ var batchToolUseTool = {
         stop_on_error: false
       };
     }
+    const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+    if (typeof governedExecute !== "function") {
+      return {
+        results: input.calls.map((call) => ({
+          tool: call.tool,
+          success: false,
+          error: "governed nested execution is unavailable; call the tool directly",
+          executionMs: 0
+        })),
+        total: input.calls.length,
+        succeeded: 0,
+        failed: input.calls.length,
+        stop_on_error: input.stop_on_error ?? false
+      };
+    }
     const results = [];
     let succeeded = 0;
     let failed = 0;
     if (input.parallel !== false) {
-      const promises = input.calls.map(async (call) => executeSingle(call, ctx, opts));
+      const promises = input.calls.map(async (call) => executeSingle(call, ctx, governedExecute));
       const allResults = await Promise.all(promises);
       results.push(...allResults);
       succeeded = allResults.filter((r) => r.success).length;
       failed = allResults.filter((r) => !r.success).length;
     } else {
       for (const call of input.calls) {
-        const result = await executeSingle(call, ctx, opts ?? { signal: void 0 });
+        const result = await executeSingle(call, ctx, governedExecute);
         results.push(result);
         if (result.success) {
           succeeded++;
@@ -6130,9 +6148,9 @@ var batchToolUseTool = {
     };
   }
 };
-async function executeSingle(call, ctx, opts) {
+async function executeSingle(call, ctx, governedExecute) {
   const start = Date.now();
-  const tool = ctx.tools.find((t) => t.name === call.tool);
+  const tool = ctx.tools.find((candidate) => candidate.name === call.tool);
   if (!tool) {
     return {
       tool: call.tool,
@@ -6142,11 +6160,11 @@ async function executeSingle(call, ctx, opts) {
     };
   }
   try {
-    const result = await tool.execute(call.input, ctx, opts);
+    const result = await governedExecute(call.tool, call.input);
     return {
       tool: call.tool,
-      success: true,
-      result,
+      success: result.success,
+      ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
       executionMs: Date.now() - start
     };
   } catch (e) {
@@ -6556,7 +6574,7 @@ var BrowserSessionManager = class {
   constructor(options, launcher = defaultLauncher) {
     this.launcher = launcher;
     this.artifacts = new BrowserArtifactStore(options.artifactRoot);
-    this.allowPrivateHosts = options.allowPrivateHosts ?? false;
+    this.allowPrivateHosts = options.allowPrivateHosts ?? true;
     this.allowedPrivateOrigins = options.allowedPrivateOrigins ?? [];
     this.networkProxy = new BrowserNetworkGuardProxy({
       allowPrivateHosts: this.allowPrivateHosts,
@@ -8519,6 +8537,7 @@ function detectLang(file) {
 }
 
 // src/codebase-index/go-parser.ts
+init_win32_resolve();
 import { spawn as spawn4 } from "node:child_process";
 import * as os5 from "node:os";
 import * as path14 from "node:path";
@@ -8827,27 +8846,42 @@ async function syncGoParse(filePath, content, lang) {
   try {
     const scriptPath = path14.join(tmpDir, "parse.go");
     await fs10.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-    const proc = spawn4("go", ["run", scriptPath], {
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stdin?.write(content);
-    proc.stdin?.end();
-    const { code } = await Promise.race([
-      new Promise((resolve14) => {
-        proc.on("close", (c) => resolve14({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const goBinary = resolveWin32Command("go");
+    const goResult = await new Promise(
+      (resolve14, reject) => {
+        let settled = false;
+        const proc = spawn4(goBinary, ["run", scriptPath], {
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
+        });
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        proc.stdin?.write(content);
+        proc.stdin?.end();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (code2) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve14({ code: code2, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = goResult;
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -8874,7 +8908,8 @@ async function syncGoParse(filePath, content, lang) {
 }
 
 // src/codebase-index/py-parser.ts
-import { spawn as spawn5 } from "node:child_process";
+init_win32_resolve();
+import { spawn as spawn5, spawnSync } from "node:child_process";
 import * as fs11 from "node:fs/promises";
 import * as os6 from "node:os";
 import * as path15 from "node:path";
@@ -9089,36 +9124,74 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-var _cachedScriptPath = null;
-async function syncPyParse(filePath, content, lang) {
-  try {
-    if (!_cachedScriptPath) {
-      const tmpDir = path15.join(os6.tmpdir(), "ws-py-parse");
-      await fs11.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path15.join(tmpDir, "parse.py");
-      await fs11.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
-    }
-    const proc = spawn5("python", [_cachedScriptPath, filePath], {
+function resolvePython() {
+  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
+  for (const name of candidates) {
+    const resolved = resolveWin32Command(name);
+    const result = spawnSync(resolved, ["--version"], {
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    if (result.error) continue;
+    if (result.status !== 0) continue;
+    return resolved;
+  }
+  return null;
+}
+function spawnPyParser(pyBinary, scriptPath, filePath, content) {
+  return new Promise((resolve14, reject) => {
+    let settled = false;
+    const proc = spawn5(pyBinary, [scriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
     proc.stdin?.write(content);
     proc.stdin?.end();
     let stdout = "";
     proc.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
     });
-    const { code } = await Promise.race([
-      new Promise((resolve14) => {
-        proc.on("close", (c) => resolve14({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+    proc.stderr?.resume();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill("SIGKILL");
+      reject(new Error("timeout"));
+    }, 15e3);
+    timer.unref?.();
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve14({ code, stdout });
+    });
+  });
+}
+var _cachedScriptPath = null;
+var _cachedPyBinary = null;
+async function syncPyParse(filePath, content, lang) {
+  try {
+    if (!_cachedScriptPath) {
+      const tmpDir = path15.join(os6.tmpdir(), "ws-py-parse");
+      await fs11.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path15.join(tmpDir, "parse.py");
+      await fs11.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+    }
+    if (!_cachedPyBinary) {
+      _cachedPyBinary = resolvePython();
+      if (!_cachedPyBinary) return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { code, stdout } = await spawnPyParser(
+      _cachedPyBinary,
+      _cachedScriptPath,
+      filePath,
+      content
+    );
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -9143,6 +9216,7 @@ async function syncPyParse(filePath, content, lang) {
 }
 
 // src/codebase-index/rs-parser.ts
+init_win32_resolve();
 import { expectDefined as expectDefined3 } from "@wrongstack/core";
 import { execFileSync, spawn as spawn6 } from "node:child_process";
 import * as fs12 from "node:fs/promises";
@@ -9187,30 +9261,45 @@ async function tryNativeParse(file, content) {
     const crateDir = path16.join(toolsDir, "syn-parser");
     const tmpFile = path16.join(crateDir, "src", "input.rs");
     await fs12.writeFile(tmpFile, content, "utf8");
-    const proc = spawn6(
-      "cargo",
-      ["run", "--manifest-path", path16.join(toolsDir, "Cargo.toml")],
-      {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      }
-    );
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    const { code } = await Promise.race([
-      new Promise((resolve14) => {
-        proc.on("close", (c) => resolve14({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const cargoBinary = resolveWin32Command("cargo");
+    const result = await new Promise(
+      (resolve14, reject) => {
+        let settled = false;
+        const proc = spawn6(
+          cargoBinary,
+          ["run", "--manifest-path", path16.join(toolsDir, "Cargo.toml")],
+          {
+            cwd: process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true
+          }
+        );
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (c) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve14({ code: c, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = result;
     if (code === 0 && stdout.trim()) {
       const symbols = JSON.parse(stdout.trim());
       return {
@@ -11570,25 +11659,46 @@ function findLadderMatches(fileLf, oldLf) {
   const needleLines = oldLf.split("\n");
   if (needleLines.length > fileLines.length) return void 0;
   const offsets = lineOffsets(fileLines);
+  const fileTrimEnd = fileLines.map((l) => l.trimEnd());
+  const needleTrimEnd = needleLines.map((l) => l.trimEnd());
   const trailing = windowScan(
-    fileLines,
-    needleLines,
+    fileTrimEnd,
+    needleTrimEnd,
     offsets,
-    (a, b) => a.trimEnd() === b.trimEnd()
+    fileLines,
+    (a, b) => a === b
   );
   if (trailing.length > 0) return { tier: "trailing-whitespace", matches: trailing };
-  const normalizedLen = needleLines.reduce((n, l) => n + l.trim().length, 0);
+  const normalizedLen = needleTrimEnd.reduce((n, l) => n + l.trimStart().length, 0);
   if (normalizedLen < MIN_NORMALIZED_NEEDLE_CHARS) return void 0;
-  const normalized = windowScan(fileLines, needleLines, offsets, (a, b) => a.trim() === b.trim());
+  const fileTrimmed = fileTrimEnd.map((l) => l.trimStart());
+  const needleTrimmed = needleTrimEnd.map((l) => l.trimStart());
+  const normalized = windowScan(
+    fileTrimmed,
+    needleTrimmed,
+    offsets,
+    fileLines,
+    (a, b) => a === b
+  );
   if (normalized.length > 0) return { tier: "whitespace-normalized", matches: normalized };
   return fuzzyScan(fileLines, needleLines, offsets);
 }
 function lineAt(text, pos) {
+  if (pos < 512) {
+    let line2 = 1;
+    for (let i = 0; i < pos; i++) {
+      if (text.charCodeAt(i) === 10) line2++;
+    }
+    return line2;
+  }
   let line = 1;
-  for (let i = 0; i < pos; i++) {
-    if (text.charCodeAt(i) === 10) line++;
+  let search = 0;
+  while (true) {
+    const idx = text.indexOf("\n", search);
+    if (idx === -1 || idx >= pos) return line;
+    search = idx + 1;
+    line++;
   }
-  return line;
 }
 function lineOffsets(lines) {
   const out = new Array(lines.length);
@@ -11607,19 +11717,19 @@ function windowToMatch(fileLines, offsets, start, windowLen) {
     startLine: start + 1
   };
 }
-function windowScan(fileLines, needleLines, offsets, eq) {
+function windowScan(comparisonLines, needleLines, offsets, originalLines, eq) {
   const n = needleLines.length;
   const out = [];
-  for (let i = 0; i + n <= fileLines.length; i++) {
+  for (let i = 0; i + n <= comparisonLines.length; i++) {
     let all = true;
     for (let j = 0; j < n; j++) {
-      if (!eq(fileLines[i + j], needleLines[j])) {
+      if (!eq(comparisonLines[i + j], needleLines[j])) {
         all = false;
         break;
       }
     }
     if (all) {
-      out.push(windowToMatch(fileLines, offsets, i, n));
+      out.push(windowToMatch(originalLines, offsets, i, n));
       i += n - 1;
     }
   }
@@ -11941,8 +12051,10 @@ var editTool = {
         note: autoReadNote
       };
     }
+    opts?.signal?.throwIfAborted();
     const ladder = findLadderMatches(fileLf, oldLf);
     if (!ladder) {
+      opts?.signal?.throwIfAborted();
       const hint = nearestMatchHint(fileLf, oldLf);
       throw new ToolValidationError({
         message: `edit: no match for old_string in "${input.path}".${hint ? ` Nearest match near line ${hint.line}:
@@ -12010,6 +12122,7 @@ Compare this against your old_string and retry with the file's actual text.` : "
       before: original,
       after: newFile
     });
+    opts?.signal?.throwIfAborted();
     const diff = unifiedDiff(original, newFile, {
       fromFile: input.path,
       toFile: input.path
@@ -15271,7 +15384,7 @@ function toYaml(data, indent = 0) {
 }
 
 // src/kanban.ts
-import { deserializeTaskGraph, serializeTaskGraph } from "@wrongstack/core";
+import { deserializeTaskGraph as deserializeTaskGraph2, loadTasks as loadTasks2, serializeTaskGraph } from "@wrongstack/core";
 import {
   addCheckToTask,
   addColumn,
@@ -15283,18 +15396,19 @@ import {
   assignTask,
   claimReadyTask,
   copyTaskToBoard,
-  createBoard,
+  createBoard as createBoard2,
+  createBoardFromTaskGraph,
   duplicateBoard,
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
   generateBoardFromDescription,
-  getBoard,
+  getBoard as getBoard2,
   getKanbanOrchestrationSnapshot,
   getKanbanQueueHealth,
   getTask,
   getTaskChain,
   heartbeatTaskAssignment,
-  listBoards,
+  listBoards as listBoards2,
   listKanbanEvents,
   listReadyTasks,
   mergeTasks,
@@ -15302,21 +15416,244 @@ import {
   parseLinesIntoTasks,
   recoverStaleTaskAssignments,
   releaseTaskClaim,
-  removeBoard,
+  removeBoard as removeBoard2,
   removeColumn,
   removeTask,
   searchKanban,
   setTaskChain,
   splitTask,
-  syncBoardFromTaskGraph,
+  syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
   transferTaskToBoard,
-  updateBoard,
+  updateBoard as updateBoard2,
   updateCheckOnTask,
   updateColumn,
   updateGoalMetricOnTask,
   updateTask,
   updateTaskAssignment
 } from "@wrongstack/kanban";
+
+// src/session-kanban.ts
+import {
+  deserializeTaskGraph,
+  loadPlan,
+  loadTasks,
+  mutatePlan,
+  mutateTasks
+} from "@wrongstack/core";
+import {
+  createBoard,
+  getBoard,
+  listBoards,
+  removeBoard,
+  syncBoardFromTaskGraph,
+  updateBoard
+} from "@wrongstack/kanban";
+var SESSION_BOARD_TAG = "session-work";
+var MIRROR_DISABLED_ENV = "WRONGSTACK_KANBAN_TASK_MIRROR";
+var SESSION_KANBAN_COLUMNS = [
+  { id: "todo", title: "Todo", order: 0, wipLimit: 0, color: "#2563eb" },
+  { id: "in-progress", title: "Running", order: 1, wipLimit: 1, color: "#d97706" },
+  { id: "review", title: "Preview", order: 2, wipLimit: 0, color: "#7c3aed" },
+  { id: "done", title: "Done", order: 3, wipLimit: 0, color: "#16a34a" }
+];
+var boardQueue = /* @__PURE__ */ new Map();
+var boardEnsures = /* @__PURE__ */ new Map();
+function boardKey(projectRoot, sessionId) {
+  return `${projectRoot}\0${sessionId}`;
+}
+function sessionTag(sessionId) {
+  return `session:${sessionId}`;
+}
+function sessionBoardTitle(sessionId) {
+  const leaf = sessionId.split(/[\\/]/).filter(Boolean).pop() ?? sessionId;
+  return `Session ${leaf.slice(0, 12)}`;
+}
+function sessionBoardTags(sessionId) {
+  return ["session", SESSION_BOARD_TAG, sessionTag(sessionId)];
+}
+function sameColumns(columns) {
+  return columns.length === SESSION_KANBAN_COLUMNS.length && columns.every((column, index) => column.id === SESSION_KANBAN_COLUMNS[index]?.id);
+}
+async function ensureSessionKanbanBoard(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return null;
+  const key = boardKey(projectRoot, sessionId);
+  const inFlight = boardEnsures.get(key);
+  if (inFlight) return inFlight;
+  const promise = (async () => {
+    const summary = (await listBoards(projectRoot)).find(
+      (board2) => board2.tags?.includes(sessionTag(sessionId))
+    );
+    let board = summary ? await getBoard(projectRoot, summary.id) : null;
+    if (!board) {
+      return createBoard(projectRoot, {
+        title: sessionBoardTitle(sessionId),
+        description: "Live session work: todos, tasks, and plan items.",
+        tags: sessionBoardTags(sessionId),
+        columns: SESSION_KANBAN_COLUMNS,
+        generatedBy: `session-kanban:${sessionId}`
+      });
+    }
+    if (!sameColumns(board.columns) || !board.tags?.includes(SESSION_BOARD_TAG)) {
+      board = await updateBoard(projectRoot, board.id, {
+        title: sessionBoardTitle(sessionId),
+        description: "Live session work: todos, tasks, and plan items.",
+        tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
+        columns: SESSION_KANBAN_COLUMNS
+      }) ?? board;
+    }
+    return board;
+  })();
+  boardEnsures.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    boardEnsures.delete(key);
+  }
+}
+function enqueueBoardWork(projectRoot, sessionId, work) {
+  const key = boardKey(projectRoot, sessionId);
+  const previous = boardQueue.get(key) ?? Promise.resolve();
+  const result = previous.catch(() => void 0).then(work);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  boardQueue.set(key, tail);
+  void tail.then(() => {
+    if (boardQueue.get(key) === tail) boardQueue.delete(key);
+  });
+  return result;
+}
+async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
+  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return null;
+  return enqueueBoardWork(projectRoot, sessionId, async () => {
+    const board = await ensureSessionKanbanBoard(projectRoot, sessionId);
+    if (!board) return null;
+    const result = await syncBoardFromTaskGraph(
+      projectRoot,
+      board.id,
+      deserializeTaskGraph(graph),
+      {
+        sourceSystem,
+        tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
+        archiveMissingTasks: true,
+        includeCompletedTasks: true
+      }
+    );
+    return result?.board ?? null;
+  });
+}
+function todoListToSerializedGraph(todos, sessionId) {
+  const nodes = todos.map((todo, index) => ({
+    id: todo.id,
+    title: todo.content,
+    description: todo.activeForm ?? "",
+    type: "chore",
+    priority: "medium",
+    status: todo.status,
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: `todo:${sessionId}`,
+    specId: `todo:${sessionId}`,
+    title: "Session todos",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function taskFileToSerializedGraph(tasks, sessionId) {
+  const ids = new Set(tasks.map((task) => task.id));
+  const nodes = tasks.map((task, index) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description ?? "",
+    type: task.type,
+    priority: task.priority,
+    status: task.status,
+    ...task.assignee ? { assignee: task.assignee } : {},
+    ...task.estimateHours !== void 0 ? { estimateHours: task.estimateHours } : {},
+    createdAt: index,
+    updatedAt: index
+  }));
+  const edges = tasks.flatMap(
+    (task) => (task.dependsOn ?? []).filter((dependency) => ids.has(dependency)).map((dependency) => ({
+      id: `${dependency}->${task.id}`,
+      from: dependency,
+      to: task.id,
+      type: "depends_on"
+    }))
+  );
+  const hasIncoming = new Set(edges.map((edge) => edge.to));
+  const rootNodes = nodes.filter((node) => !hasIncoming.has(node.id)).map((node) => node.id);
+  return {
+    // Keep the historical graph id so existing mirrored task cards are reused.
+    id: `session:${sessionId}`,
+    specId: `session:${sessionId}`,
+    title: "Session tasks",
+    nodes,
+    edges,
+    rootNodes: rootNodes.length ? rootNodes : nodes[0] ? [nodes[0].id] : [],
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+var PLAN_STATUS_TO_TASK = {
+  open: "pending",
+  in_progress: "in_progress",
+  done: "completed"
+};
+function planFileToSerializedGraph(items, sessionId) {
+  const nodes = items.map((item, index) => ({
+    id: item.id,
+    title: item.title,
+    description: item.details ?? "",
+    type: "chore",
+    priority: "medium",
+    status: PLAN_STATUS_TO_TASK[item.status],
+    createdAt: index,
+    updatedAt: index
+  }));
+  return {
+    id: `plan:${sessionId}`,
+    specId: `plan:${sessionId}`,
+    title: "Session plan",
+    nodes,
+    edges: [],
+    rootNodes: nodes.map((node) => node.id),
+    createdAt: 0,
+    updatedAt: 0
+  };
+}
+function projectSessionTodosToKanban(projectRoot, todos, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    todoListToSerializedGraph(todos, sessionId),
+    "session-todo"
+  );
+}
+function projectSessionTasksToKanban(projectRoot, tasks, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    taskFileToSerializedGraph(tasks, sessionId),
+    "session-task"
+  );
+}
+function projectSessionPlanToKanban(projectRoot, items, sessionId) {
+  return projectGraph(
+    projectRoot,
+    sessionId,
+    planFileToSerializedGraph(items, sessionId),
+    "session-plan"
+  );
+}
+
+// src/kanban.ts
 var kanbanTool = {
   name: "kanban",
   category: "Project",
@@ -15343,6 +15680,8 @@ var kanbanTool = {
           "export_markdown",
           "export_task_graph",
           "sync_task_graph",
+          "create_from_graph",
+          "import_session_tasks",
           "search_tasks",
           "ready_tasks",
           "snapshot",
@@ -15389,6 +15728,10 @@ var kanbanTool = {
       tags: { type: "array", items: { type: "string" } },
       labels: { type: "array", items: { type: "string" } },
       priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+      taskType: {
+        type: "string",
+        enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
+      },
       status: {
         type: "string",
         enum: [
@@ -15431,8 +15774,21 @@ var kanbanTool = {
       releaseStatus: { type: "string", enum: ["pending", "ready", "blocked"] },
       releaseReason: { type: "string" },
       clearAssignee: { type: "boolean" },
-      recoveryMode: { type: "string", enum: ["release", "retry", "fail"] },
+      recoveryMode: { type: "string", enum: ["auto", "release", "retry", "fail"] },
       recoveryNow: { type: "string" },
+      recoveryPolicyFailOnCostCeiling: { type: "boolean" },
+      recoveryPolicyReleaseOnFailureKinds: { type: "array", items: { type: "string" } },
+      recoveryPolicyReleaseOnHeartbeatDue: { type: "boolean" },
+      recoveryPolicyRetryPolicyOverride: {
+        type: "string",
+        enum: ["off", "incremental", "exponential"]
+      },
+      assignee: { type: "string" },
+      costCeilingUsd: { type: "number" },
+      retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
+      lastFailureKind: { type: "string" },
+      dependsOn: { type: "array", items: { type: "string" } },
+      estimatedHours: { type: "number" },
       taskGraph: { type: "object" },
       graphId: { type: "string" },
       specId: { type: "string" },
@@ -15488,7 +15844,7 @@ var kanbanTool = {
     try {
       switch (input.action) {
         case "list_boards": {
-          const boards = await listBoards(projectRoot);
+          const boards = await listBoards2(projectRoot);
           return { ok: true, message: `${boards.length} board(s).`, boards };
         }
         case "get_board": {
@@ -15497,7 +15853,7 @@ var kanbanTool = {
         }
         case "create_board": {
           if (!input.title) return fail("create_board requires title.");
-          const board = await createBoard(projectRoot, {
+          const board = await createBoard2(projectRoot, {
             title: input.title,
             ...input.description !== void 0 ? { description: input.description } : {},
             ...input.tags !== void 0 ? { tags: input.tags } : {},
@@ -15507,7 +15863,7 @@ var kanbanTool = {
         }
         case "update_board": {
           if (!input.boardId) return fail("update_board requires boardId.");
-          const board = await updateBoard(projectRoot, input.boardId, {
+          const board = await updateBoard2(projectRoot, input.boardId, {
             ...input.title !== void 0 ? { title: input.title } : {},
             ...input.description !== void 0 ? { description: input.description } : {},
             ...input.tags !== void 0 ? { tags: input.tags } : {}
@@ -15527,7 +15883,7 @@ var kanbanTool = {
         }
         case "delete_board": {
           if (!input.boardId) return fail("delete_board requires boardId.");
-          const removed = await removeBoard(projectRoot, input.boardId);
+          const removed = await removeBoard2(projectRoot, input.boardId);
           return { ok: removed, message: removed ? "Board deleted." : "Board not found." };
         }
         case "generate_board": {
@@ -15538,14 +15894,14 @@ var kanbanTool = {
             ...input.context !== void 0 ? { context: input.context } : {},
             ...input.columns !== void 0 ? { columns: input.columns } : {}
           });
-          const board = await createBoard(projectRoot, boardInput);
+          const board = await createBoard2(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.");
+          return okBoard(await getBoard2(projectRoot, board.id) ?? board, "Board generated.");
         }
         case "export_markdown": {
           const board = await requireBoard(projectRoot, input.boardId);
@@ -15578,8 +15934,8 @@ var kanbanTool = {
           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, {
+          const graph = deserializeTaskGraph2(input.taskGraph);
+          const result = await syncBoardFromTaskGraph2(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 } : {},
@@ -15596,6 +15952,59 @@ var kanbanTool = {
             board: result.board
           } : fail("Board not found.");
         }
+        case "create_from_graph": {
+          if (!input.taskGraph) return fail("create_from_graph requires taskGraph.");
+          const graph = deserializeTaskGraph2(input.taskGraph);
+          const { board } = await createBoardFromTaskGraph(projectRoot, 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 } : {}
+          });
+          return {
+            ok: true,
+            message: `Created board "${board.title}" from task graph with ${board.tasks.length} tasks.`,
+            board
+          };
+        }
+        case "import_session_tasks": {
+          const taskPath = ctx.meta?.["task.path"];
+          if (!taskPath) return fail("No session task file for this session.");
+          const file = await loadTasks2(taskPath);
+          if (!file || file.tasks.length === 0) return fail("No session tasks to import.");
+          const sessionId = ctx.session?.id ?? file.sessionId ?? "session";
+          const graph = deserializeTaskGraph2(taskFileToSerializedGraph(file.tasks, sessionId));
+          const tags = ["session", `session:${sessionId}`];
+          const existing = (await listBoards2(projectRoot)).find(
+            (b) => b.tags?.includes(`session:${sessionId}`)
+          );
+          if (existing) {
+            const result = await syncBoardFromTaskGraph2(projectRoot, existing.id, graph, {
+              sourceSystem: "session",
+              tags,
+              archiveMissingTasks: true,
+              includeCompletedTasks: true
+            });
+            return result ? {
+              ok: true,
+              message: `Synced ${file.tasks.length} session tasks into board "${result.board.title}".`,
+              board: result.board
+            } : fail("Session board vanished mid-sync.");
+          }
+          const { board } = await createBoardFromTaskGraph(projectRoot, graph, {
+            title: `Session tasks (${sessionId.slice(0, 8)})`,
+            sourceSystem: "session",
+            tags
+          });
+          return {
+            ok: true,
+            message: `Imported ${file.tasks.length} session tasks into new board "${board.title}".`,
+            board
+          };
+        }
         case "search_tasks": {
           const tasks = await searchKanban(projectRoot, {
             query: input.query,
@@ -16032,7 +16441,7 @@ function okTask(board, task, message) {
   return { ok: true, message, board, task };
 }
 async function requireBoard(projectRoot, boardId) {
-  return boardId ? getBoard(projectRoot, boardId) : null;
+  return boardId ? getBoard2(projectRoot, boardId) : null;
 }
 function taskInput(input) {
   const assignment = hasAssignmentInput(input) ? assignmentForTaskCreate(input) : void 0;
@@ -16041,14 +16450,23 @@ function taskInput(input) {
     columnId: input.columnId,
     description: input.description,
     priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
     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] } : {},
+    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
     ...assignment ? { assignment } : {}
   };
 }
+function mergedDependsOn(input) {
+  const ids = [
+    ...input.dependsOn ?? [],
+    ...input.dependencyTaskId !== void 0 ? [input.dependencyTaskId] : []
+  ].filter((id, i, arr) => id && arr.indexOf(id) === i);
+  return ids.length > 0 ? ids : void 0;
+}
 function taskPatch(input) {
   return {
     title: input.title,
@@ -16056,10 +16474,12 @@ function taskPatch(input) {
     columnId: input.columnId,
     order: input.order,
     priority: input.priority,
+    ...input.taskType !== void 0 ? { type: input.taskType } : {},
     status: input.status,
     labels: input.labels,
     assignedAgent: input.agentId,
-    ...input.dependencyTaskId !== void 0 ? { dependsOn: [input.dependencyTaskId] } : {}
+    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {}
   };
 }
 function assignmentInput(input) {
@@ -16804,12 +17224,12 @@ import {
   deriveTodosFromPlanItem,
   formatPlan,
   getPlanTemplate,
-  mutatePlan,
+  mutatePlan as mutatePlan2,
   removePlanItem,
   setPlanItemStatus
 } from "@wrongstack/core";
 import {
-  mutateTasks,
+  mutateTasks as mutateTasks2,
   formatTaskList
 } from "@wrongstack/core";
 import { randomUUID } from "node:crypto";
@@ -16896,7 +17316,7 @@ var planTool = {
     let didTaskify = false;
     let plan;
     try {
-      plan = await mutatePlan(planPath, sessionId, async (p) => {
+      plan = await mutatePlan2(planPath, sessionId, async (p) => {
         switch (input.action) {
           case "show":
             break;
@@ -17022,6 +17442,7 @@ var planTool = {
         open: 0
       };
     }
+    await projectSessionPlanToKanban(ctx.projectRoot, plan.items, sessionId);
     if (early) return early;
     if (didTaskify) {
       const taskPathRaw = ctx.meta["task.path"];
@@ -17035,7 +17456,7 @@ var planTool = {
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       try {
-        const taskFile = await mutateTasks(taskPath, sessionId, (f) => {
+        const taskFile = await mutateTasks2(taskPath, sessionId, (f) => {
           f.tasks.push({
             id: `task_${randomUUID()}`,
             title: taskifyMeta.title,
@@ -18172,11 +18593,11 @@ import {
   formatTaskList as formatTaskList2
 } from "@wrongstack/core";
 import {
-  mutateTasks as mutateTasks2
+  mutateTasks as mutateTasks3
 } from "@wrongstack/core";
 import {
   addPlanItem as addPlanItem2,
-  mutatePlan as mutatePlan2,
+  mutatePlan as mutatePlan3,
   formatPlan as formatPlan2
 } from "@wrongstack/core";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -18296,7 +18717,7 @@ var taskTool = {
     let todosToReplace = null;
     let file;
     try {
-      file = await mutateTasks2(taskPath, sessionId, async (f) => {
+      file = await mutateTasks3(taskPath, sessionId, async (f) => {
         switch (input.action) {
           case "show":
             break;
@@ -18486,6 +18907,7 @@ var taskTool = {
       };
     }
     if (todosToReplace) ctx.state.replaceTodos(todosToReplace);
+    await projectSessionTasksToKanban(ctx.projectRoot, file.tasks, sessionId);
     if (early) return early;
     if (didPlanify) {
       const { title, details } = planifyMeta;
@@ -18499,7 +18921,7 @@ var taskTool = {
         }
         let formatted = "";
         try {
-          await mutatePlan2(planPath, sessionId, (pf) => {
+          await mutatePlan3(planPath, sessionId, (pf) => {
             const { plan: updated } = addPlanItem2(pf, title, details || void 0);
             formatted = formatPlan2(updated);
             return updated;
@@ -18731,8 +19153,7 @@ function parseResult(runner, result, duration) {
 }
 
 // src/todo.ts
-import { loadPlan, savePlan, setPlanItemStatus as setPlanItemStatus2 } from "@wrongstack/core";
-import { loadTasks, saveTasks } from "@wrongstack/core";
+import { loadPlan as loadPlan2, loadTasks as loadTasks3, savePlan, saveTasks, setPlanItemStatus as setPlanItemStatus2 } from "@wrongstack/core";
 var todoTool = {
   name: "todo",
   category: "Session",
@@ -18741,7 +19162,7 @@ var todoTool = {
   permission: "auto",
   mutating: false,
   // mutates only conversation state (ctx.todos), not external state — no confirmation needed
-  timeoutMs: 1e3,
+  timeoutMs: 5e3,
   capabilities: ["session.todo"],
   icon: "todo",
   inputSchema: {
@@ -18793,16 +19214,21 @@ var todoTool = {
       }
     }
     ctx.state.replaceTodos(items);
+    await projectSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
     const completedPlanIds = /* @__PURE__ */ new Set();
     const completedTaskIds = /* @__PURE__ */ new Set();
     const pendingPlanIds = /* @__PURE__ */ new Set();
     const pendingTaskIds = /* @__PURE__ */ new Set();
     for (const item of items) {
       if (item.promotedFromPlan) {
-        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(item.promotedFromPlan);
+        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(
+          item.promotedFromPlan
+        );
       }
       if (item.promotedFromTask) {
-        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(item.promotedFromTask);
+        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(
+          item.promotedFromTask
+        );
       }
     }
     for (const planId of completedPlanIds) {
@@ -18810,7 +19236,7 @@ var todoTool = {
       const planPath = ctx.meta["plan.path"];
       if (typeof planPath !== "string" || !planPath) continue;
       try {
-        const plan = await loadPlan(planPath);
+        const plan = await loadPlan2(planPath);
         if (plan) {
           const updated = setPlanItemStatus2(plan, planId, "done");
           await savePlan(planPath, updated);
@@ -18823,7 +19249,7 @@ var todoTool = {
       const taskPath = ctx.meta["task.path"];
       if (typeof taskPath !== "string" || !taskPath) continue;
       try {
-        const file = await loadTasks(taskPath);
+        const file = await loadTasks3(taskPath);
         if (file) {
           const task = file.tasks.find((t) => t.id === taskId);
           if (task && task.status !== "completed") {