@wrongstack/tools 0.286.0 → 0.287.0

package/dist/index.js

@@ -2561,8 +2561,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, signal)
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename8, profiles, state) {
-  const lower = basename8.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename9, profiles, state) {
+  const lower = basename9.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2573,7 +2573,7 @@ function collectFileEvidence(directory, fullPath, basename8, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename8,
+        value: basename9,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -6373,6 +6373,9 @@ ${hint}` : ""),
 };
 
 // src/batch-tool-use.ts
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "@wrongstack/core";
 var batchToolUseTool = {
   name: "batch_tool_use",
   category: "Meta",
@@ -6409,7 +6412,7 @@ var batchToolUseTool = {
     },
     required: ["calls"]
   },
-  async execute(input, ctx, opts) {
+  async execute(input, ctx, _opts) {
     if (!input?.calls || input.calls.length === 0) {
       return {
         results: [],
@@ -6419,18 +6422,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++;
@@ -6449,9 +6467,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,
@@ -6461,11 +6479,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) {
@@ -6870,7 +6888,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,
@@ -8844,6 +8862,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";
@@ -9152,27 +9171,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((resolve15) => {
-        proc.on("close", (c) => resolve15({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const goBinary = resolveWin32Command("go");
+    const goResult = await new Promise(
+      (resolve15, 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);
+          resolve15({ code: code2, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = goResult;
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -9199,7 +9233,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";
@@ -9414,36 +9449,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((resolve15, 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((resolve15) => {
-        proc.on("close", (c) => resolve15({ 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);
+      resolve15({ 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() };
     }
@@ -9468,6 +9541,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";
@@ -9512,30 +9586,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((resolve15) => {
-        proc.on("close", (c) => resolve15({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const cargoBinary = resolveWin32Command("cargo");
+    const result = await new Promise(
+      (resolve15, 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);
+          resolve15({ code: c, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = result;
     if (code === 0 && stdout.trim()) {
       const symbols = JSON.parse(stdout.trim());
       return {
@@ -9630,9 +9719,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename8 = path17.basename(file).toLowerCase();
-  const isPackageJson = basename8 === "package.json";
-  const isTsconfig = basename8 === "tsconfig.json" || basename8 === "tsconfig.build.json";
+  const basename9 = path17.basename(file).toLowerCase();
+  const isPackageJson = basename9 === "package.json";
+  const isTsconfig = basename9 === "tsconfig.json" || basename9 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -11954,25 +12043,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);
@@ -11991,19 +12101,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;
     }
   }
@@ -12325,8 +12435,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}:
@@ -12394,6 +12506,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
@@ -15401,7 +15514,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,
@@ -15413,18 +15526,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,
@@ -15432,21 +15546,494 @@ 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 { watch } from "node:fs";
+import { basename as basename8, dirname as dirname13 } from "node:path";
+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();
+var bindings = /* @__PURE__ */ new WeakMap();
+var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
+var activeSessionBoards = /* @__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 sessionIdFromTags(tags) {
+  const tag = tags?.find((candidate) => candidate.startsWith("session:"));
+  return tag?.slice("session:".length) || null;
+}
+function isOwnedSessionBoard(tags) {
+  return Boolean(tags?.includes(SESSION_BOARD_TAG) && sessionIdFromTags(tags));
+}
+function retainActiveSessionBoard(projectRoot, sessionId) {
+  const key = boardKey(projectRoot, sessionId);
+  activeSessionBoards.set(key, (activeSessionBoards.get(key) ?? 0) + 1);
+}
+function releaseActiveSessionBoard(projectRoot, sessionId) {
+  const key = boardKey(projectRoot, sessionId);
+  const remaining = (activeSessionBoards.get(key) ?? 0) - 1;
+  if (remaining > 0) activeSessionBoards.set(key, remaining);
+  else activeSessionBoards.delete(key);
+}
+function isSessionBoardActive(projectRoot, sessionId) {
+  return (activeSessionBoards.get(boardKey(projectRoot, sessionId)) ?? 0) > 0;
+}
+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 removeEmptySessionBoard(projectRoot, boardId, sessionId) {
+  return enqueueBoardWork(projectRoot, sessionId, async () => {
+    if (isSessionBoardActive(projectRoot, sessionId)) return null;
+    const board = await getBoard(projectRoot, boardId);
+    if (!board || board.tasks.length > 0 || !isOwnedSessionBoard(board.tags)) return null;
+    if (sessionIdFromTags(board.tags) !== sessionId) return null;
+    return await removeBoard(projectRoot, board.id) ? board.id : null;
+  });
+}
+async function cleanupSessionKanbanBoardIfEmpty(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return [];
+  if (isSessionBoardActive(projectRoot, sessionId)) return [];
+  const candidates = (await listBoards(projectRoot)).filter(
+    (board) => board.taskCount === 0 && isOwnedSessionBoard(board.tags) && sessionIdFromTags(board.tags) === sessionId
+  );
+  const removed = await Promise.all(
+    candidates.map((board) => removeEmptySessionBoard(projectRoot, board.id, sessionId))
+  );
+  return removed.filter((boardId) => Boolean(boardId));
+}
+async function cleanupEmptySessionKanbanBoards(projectRoot, activeSessionId = "") {
+  if (!projectRoot || process.env[MIRROR_DISABLED_ENV] === "0") return [];
+  const candidates = (await listBoards(projectRoot)).flatMap((board) => {
+    const ownerSessionId = sessionIdFromTags(board.tags);
+    return board.taskCount === 0 && isOwnedSessionBoard(board.tags) && ownerSessionId && ownerSessionId !== activeSessionId && !isSessionBoardActive(projectRoot, ownerSessionId) ? [{ boardId: board.id, sessionId: ownerSessionId }] : [];
+  });
+  const removed = await Promise.all(
+    candidates.map(
+      ({ boardId, sessionId }) => removeEmptySessionBoard(projectRoot, boardId, sessionId)
+    )
+  );
+  return removed.filter((boardId) => Boolean(boardId));
+}
+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"
+  );
+}
+function fireAndForget(work) {
+  void work.catch(() => {
+  });
+}
+function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
+  fireAndForget(projectSessionTodosToKanban(projectRoot, todos, sessionId));
+}
+function mirrorSessionTasksToKanban(projectRoot, tasks, sessionId) {
+  fireAndForget(projectSessionTasksToKanban(projectRoot, tasks, sessionId));
+}
+function mirrorSessionPlanToKanban(projectRoot, items, sessionId) {
+  fireAndForget(projectSessionPlanToKanban(projectRoot, items, sessionId));
+}
+function attachSessionKanbanMirror(context) {
+  const existing = bindings.get(context);
+  if (existing) return existing;
+  const attachedProjectRoot = context.projectRoot ?? "";
+  let registeredSessionId = "";
+  const syncActiveSessionRegistration = () => {
+    if (!attachedProjectRoot) return;
+    const currentSessionId = context.session?.id ?? "";
+    if (currentSessionId === registeredSessionId) return;
+    if (registeredSessionId) {
+      releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+      fireAndForget(cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId));
+    }
+    registeredSessionId = currentSessionId;
+    if (registeredSessionId) {
+      retainActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+    }
+  };
+  syncActiveSessionRegistration();
+  let watcher = null;
+  let watchedDir = "";
+  let timer = null;
+  const sessionId = () => context.session?.id ?? "";
+  const refreshFiles = async () => {
+    const id = sessionId();
+    if (!id) return;
+    const planPath = context.meta["plan.path"];
+    if (typeof planPath === "string" && planPath) {
+      const plan = await loadPlan(planPath);
+      if (plan) await projectSessionPlanToKanban(context.projectRoot, plan.items, id);
+    }
+    const taskPath = context.meta["task.path"];
+    if (typeof taskPath === "string" && taskPath) {
+      const tasks = await loadTasks(taskPath);
+      if (tasks) await projectSessionTasksToKanban(context.projectRoot, tasks.tasks, id);
+    }
+  };
+  const configureWatcher = () => {
+    const planPath = context.meta["plan.path"];
+    const taskPath = context.meta["task.path"];
+    const candidate = typeof planPath === "string" && planPath ? dirname13(planPath) : typeof taskPath === "string" && taskPath ? dirname13(taskPath) : "";
+    if (!candidate || candidate === watchedDir) return;
+    watcher?.close();
+    watcher = null;
+    watchedDir = candidate;
+    try {
+      watcher = watch(candidate, { persistent: false }, (_event, filename) => {
+        const name = filename?.toString();
+        const currentPlanPath = context.meta["plan.path"];
+        const currentTaskPath = context.meta["task.path"];
+        const planName = typeof currentPlanPath === "string" ? basename8(currentPlanPath) : "";
+        const taskName = typeof currentTaskPath === "string" ? basename8(currentTaskPath) : "";
+        if (name && name !== planName && name !== taskName) return;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => fireAndForget(refreshFiles()), 60);
+      });
+      watcher.on("error", () => watcher?.close());
+    } catch {
+      watcher = null;
+      watchedDir = "";
+    }
+  };
+  const unsubscribe = context.state.onChange((change) => {
+    if (change.kind === "todos_replaced" && !suppressedTodoMirrors.has(context)) {
+      mirrorSessionTodosToKanban(
+        context.projectRoot,
+        change.completedSnapshot ?? change.todos,
+        sessionId()
+      );
+      return;
+    }
+    if (change.kind === "meta_set" && (change.key === "plan.path" || change.key === "task.path")) {
+      syncActiveSessionRegistration();
+      configureWatcher();
+      fireAndForget(ensureSessionKanbanBoard(context.projectRoot, sessionId()));
+      fireAndForget(refreshFiles());
+    }
+  });
+  configureWatcher();
+  const detach = () => {
+    unsubscribe();
+    if (timer) clearTimeout(timer);
+    watcher?.close();
+    bindings.delete(context);
+    if (attachedProjectRoot && registeredSessionId) {
+      releaseActiveSessionBoard(attachedProjectRoot, registeredSessionId);
+      fireAndForget(cleanupSessionKanbanBoardIfEmpty(attachedProjectRoot, registeredSessionId));
+      registeredSessionId = "";
+    }
+  };
+  bindings.set(context, detach);
+  return detach;
+}
+async function hydrateSessionKanban(context) {
+  const id = context.session?.id ?? "";
+  if (!id) return null;
+  await cleanupEmptySessionKanbanBoards(context.projectRoot, id);
+  let board = await ensureSessionKanbanBoard(context.projectRoot, id);
+  if (context.todos.length) {
+    board = await projectSessionTodosToKanban(context.projectRoot, context.todos, id);
+  }
+  const planPath = context.meta["plan.path"];
+  if (typeof planPath === "string" && planPath) {
+    const plan = await loadPlan(planPath);
+    if (plan) board = await projectSessionPlanToKanban(context.projectRoot, plan.items, id);
+  }
+  const taskPath = context.meta["task.path"];
+  if (typeof taskPath === "string" && taskPath) {
+    const tasks = await loadTasks(taskPath);
+    if (tasks) board = await projectSessionTasksToKanban(context.projectRoot, tasks.tasks, id);
+  }
+  return board;
+}
+function sourceStatus(task) {
+  if (task.status === "completed") return "completed";
+  if (task.status === "in_progress") return "in_progress";
+  if (task.status === "review") return "review";
+  if (task.status === "blocked") return "blocked";
+  if (task.status === "failed") return "failed";
+  return "pending";
+}
+async function applySessionKanbanTaskToSource(context, task, options = {}) {
+  const originId = task.origin?.taskId;
+  const graphId = task.origin?.graphId ?? "";
+  if (!originId) return { source: null };
+  if (task.origin?.system === "session-todo" || graphId.startsWith("todo:")) {
+    const next = options.remove ? context.todos.filter((todo) => todo.id !== originId) : context.todos.map(
+      (todo) => todo.id === originId ? {
+        ...todo,
+        content: task.title,
+        status: sourceStatus(task) === "completed" ? "completed" : sourceStatus(task) === "in_progress" || sourceStatus(task) === "review" ? "in_progress" : "pending"
+      } : todo
+    );
+    suppressedTodoMirrors.add(context);
+    try {
+      context.state.replaceTodos(next);
+    } finally {
+      suppressedTodoMirrors.delete(context);
+    }
+    return { source: "todo", todos: [...context.todos] };
+  }
+  const id = context.session?.id ?? "";
+  if (task.origin?.system === "session-plan" || graphId.startsWith("plan:")) {
+    const planPath = context.meta["plan.path"];
+    if (typeof planPath !== "string" || !planPath) return { source: "plan" };
+    const plan = await mutatePlan(planPath, id, (file) => ({
+      ...file,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      items: options.remove ? file.items.filter((item) => item.id !== originId) : file.items.map(
+        (item) => item.id === originId ? {
+          ...item,
+          title: task.title,
+          details: task.description,
+          status: task.status === "completed" ? "done" : task.status === "in_progress" || task.status === "review" ? "in_progress" : "open",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        } : item
+      )
+    }));
+    return { source: "plan", plan };
+  }
+  if (task.origin?.system === "session-task" || task.origin?.system === "session" || graphId.startsWith("session:")) {
+    const taskPath = context.meta["task.path"];
+    if (typeof taskPath !== "string" || !taskPath) return { source: "task" };
+    const tasks = await mutateTasks(taskPath, id, (file) => ({
+      ...file,
+      tasks: options.remove ? file.tasks.filter((item) => item.id !== originId) : file.tasks.map(
+        (item) => item.id === originId ? {
+          ...item,
+          title: task.title,
+          description: task.description,
+          status: sourceStatus(task),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        } : item
+      )
+    }));
+    return { source: "task", tasks };
+  }
+  return { source: null };
+}
+
+// src/kanban.ts
 var kanbanTool = {
   name: "kanban",
   category: "Project",
@@ -15473,6 +16060,8 @@ var kanbanTool = {
           "export_markdown",
           "export_task_graph",
           "sync_task_graph",
+          "create_from_graph",
+          "import_session_tasks",
           "search_tasks",
           "ready_tasks",
           "snapshot",
@@ -15519,6 +16108,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: [
@@ -15561,8 +16154,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" },
@@ -15618,7 +16224,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": {
@@ -15627,7 +16233,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 } : {},
@@ -15637,7 +16243,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 } : {}
@@ -15657,7 +16263,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": {
@@ -15668,14 +16274,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);
@@ -15708,8 +16314,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 } : {},
@@ -15726,6 +16332,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,
@@ -16162,7 +16821,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;
@@ -16171,14 +16830,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,
@@ -16186,10 +16854,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) {
@@ -16934,12 +17604,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";
@@ -17026,7 +17696,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;
@@ -17152,6 +17822,7 @@ var planTool = {
         open: 0
       };
     }
+    await projectSessionPlanToKanban(ctx.projectRoot, plan.items, sessionId);
     if (early) return early;
     if (didTaskify) {
       const taskPathRaw = ctx.meta["task.path"];
@@ -17165,7 +17836,7 @@ var planTool = {
       }
       const now2 = (/* @__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,
@@ -18302,11 +18973,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";
@@ -18426,7 +19097,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;
@@ -18616,6 +19287,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;
@@ -18629,7 +19301,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;
@@ -18861,8 +19533,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",
@@ -18871,7 +19542,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: {
@@ -18923,16 +19594,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) {
@@ -18940,7 +19616,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);
@@ -18953,7 +19629,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") {
@@ -20922,7 +21598,13 @@ var TOOL_ICON_MAP = {
   think: "brain",
   reason: "brain",
   analyze: "brain",
-  reasoning: "brain"
+  reasoning: "brain",
+  // Language intelligence
+  lsp_diagnostics: "code",
+  lsp_definition: "search",
+  lsp_completion: "code",
+  lsp_rename: "edit",
+  "codebase-lsp-search": "index"
 };
 function getToolIcon(toolName) {
   return TOOL_ICON_MAP[toolName.toLowerCase()] ?? "fallback";
@@ -20991,13 +21673,16 @@ export {
   LanguageProfileRegistry,
   OPTIONAL_TOOLS,
   PRIMARY_LANGUAGE_PROFILES,
+  SESSION_KANBAN_COLUMNS,
   TIER1_TOOLS,
   TIER2_TOOLS,
   TIER3_TOOLS,
   TOOL_ICON_CONFIG,
   TOOL_ICON_MAP,
   _resetProcessRegistry,
+  applySessionKanbanTaskToSource,
   assertBrowserUrlAllowed,
+  attachSessionKanbanMirror,
   auditTool,
   bashTool,
   batchToolUseTool,
@@ -21040,6 +21725,7 @@ export {
   e2ePlanTool,
   editTool,
   enqueueReindex,
+  ensureSessionKanbanBoard,
   ensureSessionShell,
   execTool,
   executeLanguagePlan,
@@ -21061,6 +21747,7 @@ export {
   gitTool,
   globTool,
   grepTool,
+  hydrateSessionKanban,
   indexCircuitBreaker,
   installTool,
   isExecCommandAllowed,
@@ -21077,6 +21764,9 @@ export {
   listInstances,
   logsTool,
   makeSkillTool,
+  mirrorSessionPlanToKanban,
+  mirrorSessionTasksToKanban,
+  mirrorSessionTodosToKanban,
   normalizeShell,
   onIndexStateChange,
   outdatedTool,
@@ -21086,6 +21776,9 @@ export {
   patchTool,
   planLanguageOperation,
   planTool,
+  projectSessionPlanToKanban,
+  projectSessionTasksToKanban,
+  projectSessionTodosToKanban,
   readTool,
   redactBrowserText,
   relatedMemoryTool,