@wrongstack/tools 0.303.0 → 0.305.1

package/dist/index.js

@@ -11170,7 +11170,6 @@ import * as fs12 from "node:fs";
 import * as os5 from "node:os";
 import * as path17 from "node:path";
 import { fileURLToPath } from "node:url";
-import { assertUnixSocketPathWithinLimit } from "@wrongstack/core/utils";
 
 // src/codebase-index/writer.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
@@ -12991,7 +12990,7 @@ var IndexStore = class _IndexStore {
       const ftsSchema = this.stmt(
         "SELECT sql FROM sqlite_master WHERE type='table' AND name='symbols_fts'"
       ).get();
-      if (ftsSchema?.sql && ftsSchema.sql.includes("unicode61")) {
+      if (ftsSchema?.sql?.includes("unicode61")) {
         this.db.exec("DROP TABLE IF EXISTS symbols_fts");
       }
       this.db.exec(SYMBOLS_FTS_SQL);
@@ -13484,9 +13483,13 @@ var IndexStore = class _IndexStore {
         sim: cosineSimilarity(queryVec, decodeVector(r.vector))
       })).sort((a, b) => b.sim - a.sim);
       const bm25Rank = /* @__PURE__ */ new Map();
-      bm25Rows.forEach((r, i) => bm25Rank.set(r.id, i));
+      bm25Rows.forEach((r, i) => {
+        bm25Rank.set(r.id, i);
+      });
       const vecRank = /* @__PURE__ */ new Map();
-      vecScores.forEach((r, i) => vecRank.set(r.id, i));
+      vecScores.forEach((r, i) => {
+        vecRank.set(r.id, i);
+      });
       const fused = reciprocalRankFusion(bm25Rank, vecRank, 60);
       const fusedScore = new Map(fused);
       const sorted = [...bm25Rows].sort(
@@ -14889,6 +14892,86 @@ import {
   isFrugalPerf
 } from "@wrongstack/core/utils";
 
+// src/codebase-index/content-hash.ts
+var PRIME64_1 = 0x9e3779b185ebca87n;
+var PRIME64_2 = 0xc2b2ae3d27d4eb4fn;
+var PRIME64_3 = 0x165667b19e3779f9n;
+var PRIME64_4 = 0x85ebca77c2b2ae63n;
+var PRIME64_5 = 0x27d4eb2f165667c5n;
+var MASK64 = 0xffffffffffffffffn;
+function mul64(a, b) {
+  return (a & MASK64) * (b & MASK64) & MASK64;
+}
+function rotl64(x, n) {
+  const v = x & MASK64;
+  return (v << BigInt(n) | v >> BigInt(64 - n)) & MASK64;
+}
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 7; i >= 0; i--) {
+    v = v << 8n | BigInt(buf[off + i] ?? 0);
+  }
+  return v & MASK64;
+}
+function readU32LE(buf, off) {
+  return (BigInt(buf[off] ?? 0) | BigInt(buf[off + 1] ?? 0) << 8n | BigInt(buf[off + 2] ?? 0) << 16n | BigInt(buf[off + 3] ?? 0) << 24n) & MASK64;
+}
+function xxh64Round(acc, lane) {
+  return mul64(rotl64(acc + mul64(lane, PRIME64_2) & MASK64, 31), PRIME64_1);
+}
+function xxh64MergeRound(acc, val) {
+  return mul64(acc ^ xxh64Round(0n, val), PRIME64_1) + PRIME64_4 & MASK64;
+}
+function xxhash64Hex(buf, explicitLen) {
+  const length = explicitLen ?? buf.length;
+  let h;
+  let off = 0;
+  if (length >= 32) {
+    let v1 = PRIME64_1 + PRIME64_2 & MASK64;
+    let v2 = PRIME64_2;
+    let v3 = 0n;
+    let v4 = 0n - PRIME64_1 & MASK64;
+    const end32 = length - 32;
+    while (off <= end32) {
+      v1 = xxh64Round(v1, readU64LE(buf, off));
+      v2 = xxh64Round(v2, readU64LE(buf, off + 8));
+      v3 = xxh64Round(v3, readU64LE(buf, off + 16));
+      v4 = xxh64Round(v4, readU64LE(buf, off + 24));
+      off += 32;
+    }
+    h = rotl64(v1, 1) + rotl64(v2, 7) + rotl64(v3, 12) + rotl64(v4, 18) & MASK64;
+    h = xxh64MergeRound(h, v1);
+    h = xxh64MergeRound(h, v2);
+    h = xxh64MergeRound(h, v3);
+    h = xxh64MergeRound(h, v4);
+  } else {
+    h = PRIME64_5;
+  }
+  h = h + BigInt(length) & MASK64;
+  while (off + 8 <= length) {
+    const k1 = xxh64Round(0n, readU64LE(buf, off));
+    h = mul64(rotl64(h ^ k1, 27), PRIME64_1) + PRIME64_4 & MASK64;
+    off += 8;
+  }
+  if (off + 4 <= length) {
+    h = mul64(rotl64(h ^ mul64(readU32LE(buf, off), PRIME64_1), 23), PRIME64_2) + PRIME64_3 & MASK64;
+    off += 4;
+  }
+  while (off < length) {
+    h = mul64(rotl64(h ^ mul64(BigInt(buf[off] ?? 0), PRIME64_5), 11), PRIME64_1) & MASK64;
+    off += 1;
+  }
+  h = (h ^ h >> 33n) & MASK64;
+  h = mul64(h, PRIME64_2);
+  h = (h ^ h >> 29n) & MASK64;
+  h = mul64(h, PRIME64_3);
+  h = (h ^ h >> 32n) & MASK64;
+  return h.toString(16).padStart(16, "0");
+}
+function xxhash64String(content) {
+  return xxhash64Hex(new TextEncoder().encode(content));
+}
+
 // src/codebase-index/gitignore.ts
 import * as fs14 from "node:fs/promises";
 import * as path18 from "node:path";
@@ -15616,91 +15699,14 @@ function getParserPool() {
   return _pool;
 }
 
-// src/codebase-index/content-hash.ts
-var PRIME64_1 = 0x9e3779b185ebca87n;
-var PRIME64_2 = 0xc2b2ae3d27d4eb4fn;
-var PRIME64_3 = 0x165667b19e3779f9n;
-var PRIME64_4 = 0x85ebca77c2b2ae63n;
-var PRIME64_5 = 0x27d4eb2f165667c5n;
-var MASK64 = 0xffffffffffffffffn;
-function mul64(a, b) {
-  return (a & MASK64) * (b & MASK64) & MASK64;
-}
-function rotl64(x, n) {
-  const v = x & MASK64;
-  return (v << BigInt(n) | v >> BigInt(64 - n)) & MASK64;
-}
-function readU64LE(buf, off) {
-  let v = 0n;
-  for (let i = 7; i >= 0; i--) {
-    v = v << 8n | BigInt(buf[off + i] ?? 0);
-  }
-  return v & MASK64;
-}
-function readU32LE(buf, off) {
-  return (BigInt(buf[off] ?? 0) | BigInt(buf[off + 1] ?? 0) << 8n | BigInt(buf[off + 2] ?? 0) << 16n | BigInt(buf[off + 3] ?? 0) << 24n) & MASK64;
-}
-function xxh64Round(acc, lane) {
-  return mul64(rotl64(acc + mul64(lane, PRIME64_2) & MASK64, 31), PRIME64_1);
-}
-function xxh64MergeRound(acc, val) {
-  return mul64(acc ^ xxh64Round(0n, val), PRIME64_1) + PRIME64_4 & MASK64;
-}
-function xxhash64Hex(buf, explicitLen) {
-  const length = explicitLen ?? buf.length;
-  let h;
-  let off = 0;
-  if (length >= 32) {
-    let v1 = PRIME64_1 + PRIME64_2 & MASK64;
-    let v2 = PRIME64_2;
-    let v3 = 0n;
-    let v4 = 0n - PRIME64_1 & MASK64;
-    const end32 = length - 32;
-    while (off <= end32) {
-      v1 = xxh64Round(v1, readU64LE(buf, off));
-      v2 = xxh64Round(v2, readU64LE(buf, off + 8));
-      v3 = xxh64Round(v3, readU64LE(buf, off + 16));
-      v4 = xxh64Round(v4, readU64LE(buf, off + 24));
-      off += 32;
-    }
-    h = rotl64(v1, 1) + rotl64(v2, 7) + rotl64(v3, 12) + rotl64(v4, 18) & MASK64;
-    h = xxh64MergeRound(h, v1);
-    h = xxh64MergeRound(h, v2);
-    h = xxh64MergeRound(h, v3);
-    h = xxh64MergeRound(h, v4);
-  } else {
-    h = PRIME64_5;
-  }
-  h = h + BigInt(length) & MASK64;
-  while (off + 8 <= length) {
-    const k1 = xxh64Round(0n, readU64LE(buf, off));
-    h = mul64(rotl64(h ^ k1, 27), PRIME64_1) + PRIME64_4 & MASK64;
-    off += 8;
-  }
-  if (off + 4 <= length) {
-    h = mul64(rotl64(h ^ mul64(readU32LE(buf, off), PRIME64_1), 23), PRIME64_2) + PRIME64_3 & MASK64;
-    off += 4;
-  }
-  while (off < length) {
-    h = mul64(rotl64(h ^ mul64(BigInt(buf[off] ?? 0), PRIME64_5), 11), PRIME64_1) & MASK64;
-    off += 1;
-  }
-  h = (h ^ h >> 33n) & MASK64;
-  h = mul64(h, PRIME64_2);
-  h = (h ^ h >> 29n) & MASK64;
-  h = mul64(h, PRIME64_3);
-  h = (h ^ h >> 32n) & MASK64;
-  return h.toString(16).padStart(16, "0");
-}
-function xxhash64String(content) {
-  return xxhash64Hex(new TextEncoder().encode(content));
-}
-
 // src/codebase-index/indexer.ts
 var YIELD_EVERY_N = 50;
 function resolveParallelBatch() {
   return indexParallelBatchSize(availableParallelism());
 }
+function shouldUseParserWorkerPool(candidateFileCount, parseBatchCount) {
+  return !isFrugalPerf() && candidateFileCount >= WORKER_POOL_THRESHOLD && parseBatchCount > 1;
+}
 function yieldEventLoop() {
   return new Promise((resolve17) => setImmediate(resolve17));
 }
@@ -15877,11 +15883,7 @@ async function resolveProjectRelations(store, projectRoot, opts) {
     const structure = await detectModuleRoots(projectRoot, indexedFiles);
     if (opts.signal?.aborted) return;
     store.setFilePackages(assignPackageLabels(structure, indexedFiles));
-    const resolver = new ModuleResolver(
-      structure,
-      indexedFiles,
-      store.getNamespaceDeclarations()
-    );
+    const resolver = new ModuleResolver(structure, indexedFiles, store.getNamespaceDeclarations());
     const pending2 = store.getUnresolvedImports(opts.onlyFiles);
     const resolutions = [];
     for (const entry of pending2) {
@@ -15906,6 +15908,10 @@ async function runIndexerWithStore(store, opts) {
   const errors = [];
   const langStats = {};
   let filesIndexed = 0;
+  let filesParsed = 0;
+  let filesSkipped = 0;
+  let filesEmpty = 0;
+  let filesFailed = 0;
   let symbolsIndexed = 0;
   const isGitIgnored = await loadGitignoreMatcher(projectRoot);
   let files;
@@ -15947,12 +15953,14 @@ async function runIndexerWithStore(store, opts) {
       langStats[meta.lang] = (langStats[meta.lang] ?? 0) + meta.symbolCount;
       symbolsIndexed += meta.symbolCount;
       filesIndexed++;
+      filesSkipped++;
       filesPreSkipped++;
       return false;
     });
     if (filesPreSkipped > 0) opts.onProgress?.(filesPreSkipped, totalFilesForProgress);
   }
   const parallelBatch = resolveParallelBatch();
+  const parserPoolCandidateCount = files.length;
   let filesSinceLastYield = 0;
   for (let batchStart = 0; batchStart < files.length; batchStart += parallelBatch) {
     const batchEnd = Math.min(batchStart + parallelBatch, files.length);
@@ -16045,7 +16053,7 @@ async function runIndexerWithStore(store, opts) {
       });
     }
     if (toParse.length > 0) {
-      let pool = toParse.length >= WORKER_POOL_THRESHOLD ? getParserPool() : null;
+      let pool = shouldUseParserWorkerPool(parserPoolCandidateCount, toParse.length) ? getParserPool() : null;
       if (pool) {
         try {
           await pool.ensureReady();
@@ -16095,12 +16103,14 @@ async function runIndexerWithStore(store, opts) {
         const err = settled.reason;
         if (err instanceof Error && isAbortError(err)) throw err;
         errors.push(`batch error: ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        filesFailed++;
         continue;
       }
       const result = settled.value;
       if (result.error) {
         if (result.missing) store.deleteFile(file);
         errors.push(`${file}: ${result.error}`);
+        filesFailed++;
         continue;
       }
       const { stat: stat19, lang, parsed } = result;
@@ -16108,6 +16118,7 @@ async function runIndexerWithStore(store, opts) {
         langStats[lang] = (langStats[lang] ?? 0) + result.skippedMeta.symbolCount;
         symbolsIndexed += result.skippedMeta.symbolCount;
         filesIndexed++;
+        filesSkipped++;
         const stored = existingMeta.get(file);
         if (stored && stored.mtimeMs !== result.skippedMeta.mtimeMs) {
           store.upsertFile({
@@ -16132,6 +16143,7 @@ async function runIndexerWithStore(store, opts) {
             contentHash: result.contentHash ?? ""
           });
           filesIndexed++;
+          filesEmpty++;
         }
         continue;
       }
@@ -16145,6 +16157,7 @@ async function runIndexerWithStore(store, opts) {
           contentHash: result.contentHash ?? ""
         });
         filesIndexed++;
+        filesEmpty++;
         continue;
       }
       batchEntries.push({
@@ -16166,6 +16179,7 @@ async function runIndexerWithStore(store, opts) {
           symbolsIndexed += count;
           langStats[entry.lang] = (langStats[entry.lang] ?? 0) + count;
           filesIndexed++;
+          filesParsed++;
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -16178,6 +16192,7 @@ async function runIndexerWithStore(store, opts) {
             symbolsIndexed += symbolsWithIds.length;
             langStats[entry.lang] = (langStats[entry.lang] ?? 0) + symbolsWithIds.length;
             filesIndexed++;
+            filesParsed++;
             if (entry.refs.length > 0 && symbolsWithIds.length > 0) {
               const fallbackBatch = assignRefsToSymbols2(entry.refs, symbolsWithIds);
               if (fallbackBatch.length > 0) store.insertRefsBatch(fallbackBatch);
@@ -16195,6 +16210,7 @@ async function runIndexerWithStore(store, opts) {
               contentHash: entry.contentHash
             });
           } catch (innerErr) {
+            filesFailed++;
             errors.push(
               `fallback write failed: ${entry.file}: ${innerErr instanceof Error ? innerErr.message : String(innerErr)}`
             );
@@ -16227,6 +16243,12 @@ async function runIndexerWithStore(store, opts) {
   const durationMs = Date.now() - startMs;
   return {
     filesIndexed,
+    fileOutcomes: {
+      parsed: filesParsed,
+      skipped: filesSkipped,
+      empty: filesEmpty,
+      failed: filesFailed
+    },
     symbolsIndexed,
     langStats,
     durationMs,
@@ -21106,7 +21128,7 @@ async function detectFixer(cwd) {
 init_util();
 import { spawn as spawn9 } from "node:child_process";
 import { statSync as statSync4 } from "node:fs";
-import { dirname as dirname14, resolve as resolve13, sep as sep6 } from "node:path";
+import { dirname as dirname13, resolve as resolve13, sep as sep6 } from "node:path";
 import { assessCommitSafety } from "@wrongstack/core/coordination";
 import { buildChildEnv as buildChildEnv4 } from "@wrongstack/core/utils";
 var TIMEOUT_MS2 = 3e4;
@@ -21285,7 +21307,7 @@ function findGitDir2(cwd, projectRoot) {
     } catch {
     }
     if (dir === root) break;
-    const parent = dirname14(dir);
+    const parent = dirname13(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -22847,7 +22869,6 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { loadTasks as loadTasks2 } from "@wrongstack/core/storage";
 import { deserializeTaskGraph as deserializeTaskGraph2, serializeTaskGraph } from "@wrongstack/core/tasking";
 import {
-  addColumn,
   addTask,
   adoptManagedLifecycle,
   assignTask,
@@ -22862,7 +22883,7 @@ import {
   exportBoardToTaskGraph,
   finalizeTaskCompletion,
   getBoard as getBoard3,
-  getKanbanOrchestrationSnapshot,
+  getKanbanOrchestrationSnapshot as getKanbanOrchestrationSnapshot2,
   getKanbanQueueHealth,
   getTask,
   getTaskChain,
@@ -22876,16 +22897,16 @@ import {
   recoverStaleTaskAssignments,
   releaseTaskClaim,
   removeBoard as removeBoard2,
-  removeColumn,
   removeTask,
   repairManagedTaskProjection,
+  resolveAutoAccept,
   searchKanban,
   setTaskChain,
+  stripLifecycleIssues,
   syncBoardFromTaskGraph as syncBoardFromTaskGraph2,
   transferTaskToBoard,
   transitionTask,
   updateBoard as updateBoard2,
-  updateColumn,
   updateTask as updateTask2,
   updateTaskAssignment,
   verifyTaskCompletion as verifyTaskCompletion2
@@ -22935,6 +22956,137 @@ function duplicateBoardOptions(input) {
   };
 }
 
+// src/kanban-contract-actions.ts
+import {
+  addContractEdge,
+  configureContractGraph,
+  evaluateTaskContractGraph,
+  getContractGraph,
+  removeContractEdge,
+  removeContractNode,
+  upsertContractNode
+} from "@wrongstack/kanban";
+
+// src/kanban-tool-results.ts
+function atomicityNudge(task) {
+  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
+  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
+  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
+}
+function readEnvGateEnforcement() {
+  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
+  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
+}
+function fail(message) {
+  return { ok: false, message };
+}
+function okBoard(board, message = "Board loaded.") {
+  return { ok: true, message, board };
+}
+function okTask(board, task, message) {
+  return { ok: true, message, board, task };
+}
+
+// src/kanban-contract-actions.ts
+async function handleKanbanContractAction(projectRoot, input, actor) {
+  switch (input.action) {
+    case "get_contract_graph": {
+      if (!input.boardId) return fail("get_contract_graph requires boardId.");
+      const found = await getContractGraph(projectRoot, input.boardId);
+      if (!found) return fail("Board not found.");
+      const evaluated = input.taskId ? await evaluateTaskContractGraph(projectRoot, input.boardId, input.taskId) : null;
+      if (input.taskId && !evaluated) return fail("Task not found on this board.");
+      return {
+        ok: true,
+        message: found.graph ? `Contract map: ${found.graph.nodes.length} node(s), ${found.graph.edges.length} edge(s), enforcement ${found.graph.enforcement}.` : "No contract map on this board yet. Call configure_contract_graph to start one.",
+        board: found.board,
+        contractGraph: found.graph,
+        ...evaluated ? { contractEvaluation: evaluated.evaluation } : {}
+      };
+    }
+    case "configure_contract_graph": {
+      if (!input.boardId) return fail("configure_contract_graph requires boardId.");
+      const enforcement = input.contractEnforcement ?? "advisory";
+      const board = await configureContractGraph(projectRoot, input.boardId, enforcement);
+      return board ? okBoard(board, `Contract map enforcement set to ${enforcement}.`) : fail("Board not found.");
+    }
+    case "upsert_contract_node": {
+      if (!input.boardId || !input.taskId) {
+        return fail("upsert_contract_node requires boardId and taskId.");
+      }
+      if (!input.contractNodeKind || !input.contractNodeTitle) {
+        return fail("upsert_contract_node requires contractNodeKind and contractNodeTitle.");
+      }
+      const waiver = input.contractNodeState === "waived" ? {
+        actor: actor ?? "agent",
+        reason: input.contractWaiverReason ?? "",
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      } : void 0;
+      if (waiver && !waiver.reason.trim()) {
+        return fail("A waived contract node requires contractWaiverReason.");
+      }
+      const result = await upsertContractNode(projectRoot, input.boardId, {
+        taskId: input.taskId,
+        kind: input.contractNodeKind,
+        title: input.contractNodeTitle,
+        ...input.contractNodeId !== void 0 ? { id: input.contractNodeId } : {},
+        ...input.contractNodeDescription !== void 0 ? { description: input.contractNodeDescription } : {},
+        ...input.contractNodeState !== void 0 ? { state: input.contractNodeState } : {},
+        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
+        ...input.contractCheckId !== void 0 ? { checkId: input.contractCheckId } : {},
+        ...input.contractMetricId !== void 0 ? { metricId: input.contractMetricId } : {},
+        ...waiver ? { waiver } : {},
+        ...actor !== void 0 ? { createdBy: actor } : {}
+      });
+      if (!result) return fail("Board or task not found.");
+      return {
+        ok: true,
+        message: `Contract node ${result.node.kind} "${result.node.title}" saved (${result.node.id}).`,
+        board: result.board,
+        contractGraph: result.board.contractGraph ?? null
+      };
+    }
+    case "remove_contract_node": {
+      if (!input.boardId || !input.contractNodeId) {
+        return fail("remove_contract_node requires boardId and contractNodeId.");
+      }
+      const board = await removeContractNode(projectRoot, input.boardId, input.contractNodeId);
+      return board ? okBoard(board, "Contract node removed, along with every edge that touched it.") : fail("Contract node not found.");
+    }
+    case "add_contract_edge": {
+      if (!input.boardId || !input.contractEdgeFrom || !input.contractEdgeTo) {
+        return fail("add_contract_edge requires boardId, contractEdgeFrom, and contractEdgeTo.");
+      }
+      if (!input.contractEdgeType) return fail("add_contract_edge requires contractEdgeType.");
+      const result = await addContractEdge(projectRoot, input.boardId, {
+        from: input.contractEdgeFrom,
+        to: input.contractEdgeTo,
+        type: input.contractEdgeType,
+        ...input.contractEdgeId !== void 0 ? { id: input.contractEdgeId } : {},
+        ...input.contractNodeEnforcement !== void 0 ? { enforcement: input.contractNodeEnforcement } : {},
+        ...input.contractEdgeRationale !== void 0 ? { rationale: input.contractEdgeRationale } : {},
+        ...actor !== void 0 ? { createdBy: actor } : {}
+      });
+      if (!result) return fail("Board not found.");
+      return {
+        ok: true,
+        message: `Contract edge ${result.edge.type}: ${result.edge.from} \u2192 ${result.edge.to}.`,
+        board: result.board,
+        contractGraph: result.board.contractGraph ?? null
+      };
+    }
+    case "remove_contract_edge": {
+      if (!input.boardId || !input.contractEdgeId) {
+        return fail("remove_contract_edge requires boardId and contractEdgeId.");
+      }
+      const board = await removeContractEdge(projectRoot, input.boardId, input.contractEdgeId);
+      return board ? okBoard(board, "Contract edge removed.") : fail("Contract edge not found.");
+    }
+    default:
+      return void 0;
+  }
+}
+
 // src/kanban-decomposition-actions.ts
 import {
   assessTaskAtomicity,
@@ -22966,26 +23118,6 @@ function recordKanbanVerificationEvidence(ctx, report) {
   }
 }
 
-// src/kanban-tool-results.ts
-function atomicityNudge(task) {
-  if (task.atomicityAssessment?.verdict !== "needs_decomposition") return "";
-  const reasons = task.atomicityAssessment.criteria.filter((entry) => entry.score < 1).map((entry) => entry.reason).join(" | ");
-  return ` Atomicity: needs_decomposition (score ${task.atomicityAssessment.score}) \u2014 call propose_decomposition with 2+ subtasks before dispatch. Reasons: ${reasons}`;
-}
-function readEnvGateEnforcement() {
-  const raw = process.env["WRONGSTACK_KANBAN_GATE"]?.trim().toLowerCase();
-  return raw === "strict" || raw === "soft" || raw === "off" ? raw : void 0;
-}
-function fail(message) {
-  return { ok: false, message };
-}
-function okBoard(board, message = "Board loaded.") {
-  return { ok: true, message, board };
-}
-function okTask(board, task, message) {
-  return { ok: true, message, board, task };
-}
-
 // src/kanban-decomposition-actions.ts
 async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
   switch (input.action) {
@@ -23070,20 +23202,14 @@ async function handleKanbanDecompositionAction(projectRoot, input, ctx) {
 // src/kanban-detail-actions.ts
 import {
   addCheckToTask,
-  addContractEdge,
   addDependency,
   addGoalMetricToTask,
   addLinkToTask,
   addNoteToTask,
-  configureContractGraph,
-  evaluateTaskContractGraph,
-  getContractGraph,
   getKanbanWorkbench,
-  removeContractEdge,
-  removeContractNode,
+  removeCheckFromTask,
   updateCheckOnTask,
-  updateGoalMetricOnTask,
-  upsertContractNode
+  updateGoalMetricOnTask
 } from "@wrongstack/kanban";
 
 // src/kanban-split-task-handler.ts
@@ -23149,131 +23275,6 @@ async function handleKanbanDetailAction(projectRoot, input) {
         workbench
       };
     }
-    case "get_contract_graph": {
-      if (!input.boardId) return fail("get_contract_graph requires boardId.");
-      const result = await getContractGraph(projectRoot, input.boardId);
-      return result ? {
-        ok: true,
-        message: result.graph ? `${result.graph.nodes.length} contract node(s), ${result.graph.edges.length} edge(s).` : "Contract graph is not configured.",
-        board: result.board,
-        ...result.graph ? { contractGraph: result.graph } : {}
-      } : fail("Board not found.");
-    }
-    case "configure_contract_graph": {
-      if (!input.boardId || !input.contractGraphEnforcement) {
-        return fail("configure_contract_graph requires boardId and contractGraphEnforcement.");
-      }
-      const current = await getContractGraph(projectRoot, input.boardId);
-      if (!current) return fail("Board not found.");
-      if (input.contractGraphEnforcement === "strict" && current.graph?.enforcement !== "strict") {
-        return fail(
-          "Strict Contract Map enforcement is operator-owned. Autonomous agents may use advisory maps but may not turn them into an execution gate."
-        );
-      }
-      if (current.graph?.enforcement === "strict" && input.contractGraphEnforcement !== "strict") {
-        return fail("An autonomous agent may not loosen a strict contract graph.");
-      }
-      const board = await configureContractGraph(
-        projectRoot,
-        input.boardId,
-        input.contractGraphEnforcement
-      );
-      return board ? okBoard(board, "Contract graph configured.") : fail("Board not found.");
-    }
-    case "upsert_contract_node": {
-      if (!input.boardId || !input.taskId || !input.contractNodeKind || !input.title) {
-        return fail("upsert_contract_node requires boardId, taskId, contractNodeKind, and title.");
-      }
-      if (input.contractNodeState === "waived") {
-        return fail(
-          "The autonomous kanban tool may not waive contract nodes; a human-owned review surface must record that exception."
-        );
-      }
-      if (input.contractNodeId) {
-        const current = await getContractGraph(projectRoot, input.boardId);
-        const existing = current?.graph?.nodes.find((node) => node.id === input.contractNodeId);
-        if (current?.graph?.enforcement === "strict" && existing && (existing.kind !== input.contractNodeKind || input.contractEnforcement !== void 0 && input.contractEnforcement !== existing.enforcement)) {
-          return fail(
-            "The autonomous kanban tool may not change the kind or enforcement of an existing strict contract node."
-          );
-        }
-      }
-      const result = await upsertContractNode(projectRoot, input.boardId, {
-        ...input.contractNodeId ? { id: input.contractNodeId } : {},
-        taskId: input.taskId,
-        kind: input.contractNodeKind,
-        title: input.title,
-        ...input.description !== void 0 ? { description: input.description } : {},
-        ...input.contractEnforcement !== void 0 ? { enforcement: input.contractEnforcement } : {},
-        ...input.contractNodeState !== void 0 ? { state: input.contractNodeState } : {},
-        ...input.checkId !== void 0 ? { checkId: input.checkId } : {},
-        ...input.metricId !== void 0 ? { metricId: input.metricId } : {},
-        ...input.baseline !== void 0 ? { baseline: input.baseline } : {},
-        ...input.threshold !== void 0 ? { threshold: input.threshold } : {},
-        ...input.author !== void 0 ? { createdBy: input.author } : {}
-      });
-      return result ? {
-        ...okBoard(result.board, "Contract node saved."),
-        contractGraph: result.board.contractGraph
-      } : fail("Task not found.");
-    }
-    case "link_contract_nodes": {
-      if (!input.boardId || !input.fromNodeId || !input.toNodeId || !input.contractEdgeType) {
-        return fail(
-          "link_contract_nodes requires boardId, fromNodeId, toNodeId, and contractEdgeType."
-        );
-      }
-      const result = await addContractEdge(projectRoot, input.boardId, {
-        from: input.fromNodeId,
-        to: input.toNodeId,
-        type: input.contractEdgeType,
-        ...input.contractEdgeId ? { id: input.contractEdgeId } : {},
-        ...input.contractEnforcement ? { enforcement: input.contractEnforcement } : {},
-        ...input.contractRationale ? { rationale: input.contractRationale } : {},
-        ...input.author ? { createdBy: input.author } : {}
-      });
-      return result ? {
-        ...okBoard(result.board, "Contract edge added."),
-        contractGraph: result.board.contractGraph
-      } : fail("Board not found.");
-    }
-    case "remove_contract_node": {
-      if (!input.boardId || !input.contractNodeId) {
-        return fail("remove_contract_node requires boardId and contractNodeId.");
-      }
-      const current = await getContractGraph(projectRoot, input.boardId);
-      const node = current?.graph?.nodes.find((candidate) => candidate.id === input.contractNodeId);
-      if (current?.graph?.enforcement === "strict" && node?.enforcement === "blocking") {
-        return fail("The autonomous kanban tool may not remove a blocking strict contract node.");
-      }
-      const board = await removeContractNode(projectRoot, input.boardId, input.contractNodeId);
-      return board ? okBoard(board, "Contract node removed.") : fail("Contract node not found.");
-    }
-    case "remove_contract_edge": {
-      if (!input.boardId || !input.contractEdgeId) {
-        return fail("remove_contract_edge requires boardId and contractEdgeId.");
-      }
-      const current = await getContractGraph(projectRoot, input.boardId);
-      const edge = current?.graph?.edges.find((candidate) => candidate.id === input.contractEdgeId);
-      if (current?.graph?.enforcement === "strict" && edge?.enforcement === "blocking") {
-        return fail("The autonomous kanban tool may not remove a blocking strict contract edge.");
-      }
-      const board = await removeContractEdge(projectRoot, input.boardId, input.contractEdgeId);
-      return board ? okBoard(board, "Contract edge removed.") : fail("Contract edge not found.");
-    }
-    case "evaluate_contract_graph": {
-      if (!input.boardId || !input.taskId) {
-        return fail("evaluate_contract_graph requires boardId and taskId.");
-      }
-      const result = await evaluateTaskContractGraph(projectRoot, input.boardId, input.taskId);
-      return result ? {
-        ok: result.evaluation.allowed,
-        message: result.evaluation.allowed ? "Contract graph is closed." : `Contract graph has ${result.evaluation.issues.length} unresolved issue(s).`,
-        board: result.board,
-        contractGraph: result.board.contractGraph,
-        contractEvaluation: result.evaluation
-      } : fail("Task not found.");
-    }
     case "add_dependency": {
       if (!input.boardId || !input.taskId || !input.dependencyTaskId) {
         return fail("add_dependency requires boardId, taskId, and dependencyTaskId.");
@@ -23326,8 +23327,9 @@ async function handleKanbanDetailAction(projectRoot, input) {
       }
       const board = await addCheckToTask(projectRoot, input.boardId, input.taskId, {
         description: input.checkDescription,
-        type: "manual",
-        status: input.checkStatus
+        type: input.checkType ?? "manual",
+        status: input.checkStatus,
+        ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
       });
       return board ? okBoard(board, "Check added.") : fail("Task not found.");
     }
@@ -23342,11 +23344,27 @@ async function handleKanbanDetailAction(projectRoot, input) {
         input.checkId,
         {
           ...input.checkDescription !== void 0 ? { description: input.checkDescription } : {},
-          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {}
+          ...input.checkStatus !== void 0 ? { status: input.checkStatus } : {},
+          // Promoting an existing manual criterion to an executable one is the
+          // common repair: the card was written before anyone knew the command.
+          ...input.checkType !== void 0 ? { type: input.checkType } : {},
+          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
         }
       );
       return board ? okBoard(board, "Check updated.") : fail("Check not found.");
     }
+    case "remove_check": {
+      if (!input.boardId || !input.taskId || !input.checkId) {
+        return fail("remove_check requires boardId, taskId, and checkId.");
+      }
+      const board = await removeCheckFromTask(
+        projectRoot,
+        input.boardId,
+        input.taskId,
+        input.checkId
+      );
+      return board ? okBoard(board, "Acceptance criterion removed.") : fail("Check not found on this task.");
+    }
     case "add_note": {
       if (!input.boardId || !input.taskId || !input.note)
         return fail("add_note requires boardId, taskId, and note.");
@@ -23421,14 +23439,25 @@ function taskInput(input) {
     ...input.order !== void 0 ? { order: input.order } : {},
     ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
     ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    // The system prompt has always told the model it may "set atomic: true"
+    // when creating a composite parent. It could not: the field reached
+    // neither the create input nor the patch, so the instruction described a
+    // capability that did not exist and the attempt was silently dropped.
+    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
     ...input.childTitles !== void 0 ? { childTaskIds: input.childTitles } : {},
     ...input.checkDescription !== void 0 ? {
       successCriteria: [
         {
           id: randomUUID(),
           description: input.checkDescription,
-          type: "manual",
-          status: input.checkStatus ?? "pending"
+          // `manual` only as the fallback. Hard-coding it here meant every
+          // agent-authored criterion was unverifiable by construction: the
+          // deterministic plugins never matched, the registry passed the
+          // hand-set status straight through, and "verified" collapsed into
+          // "the author ticked its own box".
+          type: input.checkType ?? "manual",
+          status: input.checkStatus ?? "pending",
+          ...input.checkNotes !== void 0 ? { notes: input.checkNotes } : {}
         }
       ]
     } : {},
@@ -23476,11 +23505,11 @@ function taskInput(input) {
   };
 }
 function mergedDependsOn(input) {
-  const ids = [
+  if (input.dependsOn === void 0 && input.dependencyTaskId === void 0) return void 0;
+  return [
     ...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 {
@@ -23494,7 +23523,15 @@ function taskPatch(input) {
     status: input.status,
     labels: input.labels,
     assignedAgent: input.agentId,
-    ...mergedDependsOn(input) ? { dependsOn: mergedDependsOn(input) } : {},
+    ...mergedDependsOn(input) !== void 0 ? { dependsOn: mergedDependsOn(input) } : {},
+    // `atomic` and `childTaskIds` are the composite-parent contract, and the
+    // managed gate reads both: an `atomic` parent may not move forward without
+    // children, and may not reach Done until every child is completed. The
+    // manager has always accepted both on a patch; only this surface withheld
+    // them, so `split_atomic` was a one-way door — delete the children and the
+    // parent was stranded with no way to declare itself a leaf again.
+    ...input.atomic !== void 0 ? { atomic: input.atomic } : {},
+    ...input.childTaskIds !== void 0 ? { childTaskIds: input.childTaskIds } : {},
     ...input.estimatedHours !== void 0 ? { estimatedHours: input.estimatedHours } : {},
     ...input.actualHours !== void 0 ? { actualHours: input.actualHours } : {}
   };
@@ -23554,8 +23591,8 @@ function assignmentForTaskCreate(input) {
 }
 
 // src/kanban-tool-schema.ts
-var KANBAN_TOOL_DESCRIPTION = "Manage and audit project-scoped multi-kanban boards through the shared IPC Kanban server and its SQLite store. Managed cards enforce fully specified details and adjacent Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions with persistent comments and evidence. Contract Map actions are optional advisory metadata unless an operator explicitly enabled strict enforcement. Use verify_completion to validate executable success criteria before Done.";
-var KANBAN_TOOL_USAGE_HINT = "Use this for durable project kanban state. Read workbench when orienting across boards; it returns bounded Now, Next, Blocked, Review lanes and operational alerts. Before coding mutation, create a fully detailed card on a managed board with executable acceptance criteria, then call start_task. The runtime blocks product mutations until start_task binds a ready Running card. Do not create, inspect, repair, or enable a Contract Map during ordinary work; every map mode stays off the execution and completion path. Worker completion enters Review; Done requires passed acceptance criteria and review evidence. Surface existing strict-map findings for operator review without stopping work to repair them.";
+var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -23568,6 +23605,7 @@ var KANBAN_INPUT_SCHEMA = {
         "duplicate_board",
         "update_board",
         "adopt_managed_lifecycle",
+        "release_managed_lifecycle",
         "delete_board",
         "generate_board",
         "export_markdown",
@@ -23579,9 +23617,6 @@ var KANBAN_INPUT_SCHEMA = {
         "ready_tasks",
         "snapshot",
         "workbench",
-        "add_column",
-        "update_column",
-        "delete_column",
         "add_task",
         "split_task",
         "merge_tasks",
@@ -23596,13 +23631,6 @@ var KANBAN_INPUT_SCHEMA = {
         "delete_task",
         "set_chain",
         "get_chain",
-        "get_contract_graph",
-        "configure_contract_graph",
-        "upsert_contract_node",
-        "link_contract_nodes",
-        "remove_contract_node",
-        "remove_contract_edge",
-        "evaluate_contract_graph",
         "claim_task",
         "release_task",
         "assign_task",
@@ -23616,49 +23644,27 @@ var KANBAN_INPUT_SCHEMA = {
         "update_goal_metric",
         "add_check",
         "update_check",
+        "remove_check",
         "add_note",
         "add_link",
         "verify_completion",
         "split_atomic",
         "assess_atomicity",
-        "propose_decomposition"
+        "propose_decomposition",
+        "get_contract_graph",
+        "configure_contract_graph",
+        "upsert_contract_node",
+        "remove_contract_node",
+        "add_contract_edge",
+        "remove_contract_edge"
       ]
     },
     boardId: { type: "string" },
     taskId: { type: "string" },
     taskIds: { type: "array", items: { type: "string" } },
     chainId: { type: "string" },
-    contractNodeId: { type: "string" },
-    contractNodeKind: {
-      type: "string",
-      enum: ["objective", "guardrail", "risk", "component", "artifact", "verification"]
-    },
-    contractNodeState: {
-      type: "string",
-      enum: ["unknown", "active", "satisfied", "violated", "resolved"]
-    },
-    contractEnforcement: {
-      type: "string",
-      enum: ["blocking", "advisory", "informational"]
-    },
-    contractGraphEnforcement: { type: "string", enum: ["off", "advisory", "strict"] },
-    contractEdgeId: { type: "string" },
-    contractEdgeType: {
-      type: "string",
-      enum: [
-        "targets",
-        "affects",
-        "must_preserve",
-        "exposes",
-        "verified_by",
-        "conflicts_with",
-        "derived_from",
-        "relates_to"
-      ]
-    },
     fromNodeId: { type: "string" },
     toNodeId: { type: "string" },
-    contractRationale: { type: "string" },
     baseline: { oneOf: [{ type: "string" }, { type: "number" }] },
     threshold: { oneOf: [{ type: "string" }, { type: "number" }] },
     columnId: { type: "string" },
@@ -23742,7 +23748,20 @@ var KANBAN_INPUT_SCHEMA = {
     costCeilingUsd: { type: "number" },
     retryPolicy: { type: "string", enum: ["off", "incremental", "exponential"] },
     lastFailureKind: { type: "string" },
-    dependsOn: { type: "array", items: { type: "string" } },
+    dependsOn: {
+      type: "array",
+      items: { type: "string" },
+      description: "Task ids this card waits on. On update_task an explicit empty array clears them \u2014 use it when a dependency was recorded in error rather than completing work nobody wants."
+    },
+    atomic: {
+      type: "boolean",
+      description: "Composite parent (true) or executable leaf (false). Set false to make a stranded parent a leaf again after its children were dropped."
+    },
+    childTaskIds: {
+      type: "array",
+      items: { type: "string" },
+      description: "Children of a composite parent. On update_task an explicit empty array detaches them all."
+    },
     estimatedHours: { type: "number" },
     actualHours: { type: "number" },
     taskGraph: { type: "object" },
@@ -23776,6 +23795,74 @@ var KANBAN_INPUT_SCHEMA = {
     checkId: { type: "string" },
     checkDescription: { type: "string" },
     checkStatus: { type: "string", enum: ["pending", "passed", "failed", "skipped"] },
+    checkType: {
+      type: "string",
+      // Only types a verifier can actually execute. `manual` is the default and
+      // means a human or agent asserts the status by hand. The rest are run by
+      // `verify_completion` against the default deterministic registry. Types
+      // with no plugin in that registry (`auto`, `review`, `agent`, `council`)
+      // are deliberately omitted: offering them would produce criteria that
+      // silently report `skipped — no verifier plugin registered`.
+      enum: ["manual", "command", "test", "file_exists", "file_matches", "git_diff", "metric"],
+      description: 'How this acceptance criterion is verified. Default "manual" (status set by hand). Any other value makes verify_completion execute it, so the criterion becomes real evidence rather than a self-assertion. Pair with checkNotes.'
+    },
+    checkNotes: {
+      type: "string",
+      description: 'The executable body for a non-manual checkType, read in preference to checkDescription. command/test: the shell command or test pattern. file_exists: the path. file_matches: JSON {"file","pattern","flags"}. git_diff: JSON {"expectedFiles","minChanges","maxChanges"}.'
+    },
+    // ── Contract map ───────────────────────────────────────────────────
+    // The card contract: what this work targets, what it must not break, what
+    // it risks, and what verifies it. Advisory by default — the readiness gate
+    // deliberately does not require map structure, so a map is an operator
+    // review aid, not work the model must complete before implementing.
+    contractEnforcement: {
+      type: "string",
+      enum: ["off", "advisory", "strict"],
+      description: "Board-level contract map enforcement. Default when first configured: advisory."
+    },
+    contractNodeId: { type: "string" },
+    contractNodeKind: {
+      type: "string",
+      enum: ["objective", "guardrail", "risk", "component", "artifact", "verification"],
+      description: "objective = what this card is for; guardrail = what must keep working; risk = what could go wrong; component/artifact = what it touches; verification = what settles it."
+    },
+    contractNodeTitle: { type: "string" },
+    contractNodeDescription: { type: "string" },
+    contractNodeState: {
+      type: "string",
+      enum: ["unknown", "active", "satisfied", "violated", "waived", "resolved"]
+    },
+    contractNodeEnforcement: {
+      type: "string",
+      enum: ["blocking", "advisory", "informational"]
+    },
+    /** Bind a node to an acceptance criterion or goal metric already on the task. */
+    contractCheckId: { type: "string" },
+    contractMetricId: { type: "string" },
+    contractWaiverReason: {
+      type: "string",
+      description: 'Required, with an actor, when contractNodeState is "waived".'
+    },
+    contractEdgeId: { type: "string" },
+    contractEdgeFrom: {
+      type: "string",
+      description: 'A contract node id, or a task id (bare or "task:<id>") for the card endpoint.'
+    },
+    contractEdgeTo: { type: "string" },
+    contractEdgeType: {
+      type: "string",
+      enum: [
+        "targets",
+        "affects",
+        "must_preserve",
+        "exposes",
+        "verified_by",
+        "conflicts_with",
+        "derived_from",
+        "relates_to"
+      ]
+    },
+    contractEdgeRationale: { type: "string" },
     note: { type: "string" },
     author: { type: "string" },
     url: { type: "string" },
@@ -23821,7 +23908,7 @@ var KANBAN_INPUT_SCHEMA = {
 
 // src/session-kanban.ts
 import { watch } from "node:fs";
-import { basename as basename13, dirname as dirname15 } from "node:path";
+import { basename as basename13, dirname as dirname14 } from "node:path";
 import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
 import {
   loadPlan,
@@ -23830,12 +23917,17 @@ import {
   mutateTasks
 } from "@wrongstack/core/storage";
 import { deserializeTaskGraph } from "@wrongstack/core/tasking";
-import { resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
+import { formatTodosForModel, resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
 import {
   bridgeKanbanSupervisor,
+  compactSessionMirrorBoard,
   createBoard,
+  DEFAULT_COLUMNS,
   getBoard as getBoard2,
+  getDependencyReadinessIssues,
+  getKanbanOrchestrationSnapshot,
   listBoards,
+  pruneSessionBoards,
   removeBoard,
   syncBoardFromTaskGraph,
   touchKanbanPresence as touchKanbanPresence2,
@@ -23843,16 +23935,14 @@ import {
 } 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 SESSION_KANBAN_COLUMNS = DEFAULT_COLUMNS.map((column) => ({
+  ...column
+}));
 var boardQueue = /* @__PURE__ */ new Map();
 var boardEnsures = /* @__PURE__ */ new Map();
 var pendingMirrors = /* @__PURE__ */ new Map();
 var activeMirrors = /* @__PURE__ */ new Set();
+var mirrorFailures = /* @__PURE__ */ new Map();
 var bindings = /* @__PURE__ */ new WeakMap();
 var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
 var activeSessionBoards = /* @__PURE__ */ new Map();
@@ -23862,6 +23952,33 @@ function boardKey(projectRoot, sessionId) {
 function mirrorKey(projectRoot, sessionId, sourceSystem) {
   return `${boardKey(projectRoot, sessionId)}\0${sourceSystem}`;
 }
+function completedReconciliationGraph(latest, candidates) {
+  const latestNodeIds = new Set(latest.nodes.map((node) => node.id));
+  const carriedNodeIds = /* @__PURE__ */ new Set();
+  const completedNodes = candidates.flatMap(
+    (candidate) => candidate.nodes.filter((node) => {
+      if (node.status !== "completed" || latestNodeIds.has(node.id) || carriedNodeIds.has(node.id)) {
+        return false;
+      }
+      carriedNodeIds.add(node.id);
+      return true;
+    })
+  );
+  if (completedNodes.length === 0) return void 0;
+  const carriedRequirements = completedNodes.flatMap(
+    (node) => node.specRequirementId ? [node.specRequirementId] : []
+  );
+  return {
+    ...latest,
+    nodes: [...latest.nodes, ...completedNodes],
+    rootNodes: [.../* @__PURE__ */ new Set([...latest.rootNodes, ...completedNodes.map((node) => node.id)])],
+    ...latest.requiredRequirementIds ? {
+      requiredRequirementIds: [
+        .../* @__PURE__ */ new Set([...latest.requiredRequirementIds, ...carriedRequirements])
+      ]
+    } : {}
+  };
+}
 function sessionTag(sessionId) {
   return `session:${sessionId}`;
 }
@@ -24002,16 +24119,44 @@ async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
         sourceSystem,
         tags: [.../* @__PURE__ */ new Set([...board.tags ?? [], ...sessionBoardTags(sessionId)])],
         archiveMissingTasks: true,
-        includeCompletedTasks: true
+        includeCompletedTasks: true,
+        // The scope ledger stays declared and accurate, but it may not veto a
+        // projection. A session mirror reflects a tactical list that shrinks by
+        // design, and refusing the sync never protected the removed row — it
+        // froze the entire board, permanently, because the stored scope then
+        // outlived every later snapshot (`session-kanban.mirror-failed`).
+        // Nothing is lost by shrinking here: `archiveMissingTasks` keeps the
+        // removed card on the board as `archived`, the reconciliation pass
+        // first walks vanished completed rows to Done, and the session journal
+        // remains the durable record.
+        allowRequirementScopeShrink: true
       }
     );
-    return result?.board ?? null;
+    if (!result) return null;
+    const compacted = await compactSessionMirrorBoard(projectRoot, board.id);
+    if (compacted?.removedTaskIds.length) {
+      return await getBoard2(projectRoot, board.id) ?? result.board;
+    }
+    return result.board;
   });
 }
 function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
   if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return;
   const key = mirrorKey(projectRoot, sessionId, sourceSystem);
-  pendingMirrors.set(key, { projectRoot, sessionId, graph, sourceSystem });
+  const previous = pendingMirrors.get(key);
+  const reconciliationGraph = previous ? completedReconciliationGraph(
+    graph,
+    [previous.reconciliationGraph, previous.graph].filter(
+      (candidate) => candidate !== void 0
+    )
+  ) : void 0;
+  pendingMirrors.set(key, {
+    projectRoot,
+    sessionId,
+    graph,
+    ...reconciliationGraph ? { reconciliationGraph } : {},
+    sourceSystem
+  });
   if (activeMirrors.has(key)) return;
   activeMirrors.add(key);
   void (async () => {
@@ -24021,20 +24166,34 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
         if (!pending2) break;
         pendingMirrors.delete(key);
         try {
+          if (pending2.reconciliationGraph) {
+            await projectGraph(
+              pending2.projectRoot,
+              pending2.sessionId,
+              pending2.reconciliationGraph,
+              pending2.sourceSystem
+            );
+          }
           await projectGraph(
             pending2.projectRoot,
             pending2.sessionId,
             pending2.graph,
             pending2.sourceSystem
           );
+          mirrorFailures.delete(boardKey(pending2.projectRoot, pending2.sessionId));
         } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          mirrorFailures.set(boardKey(pending2.projectRoot, pending2.sessionId), {
+            message,
+            sourceSystem: pending2.sourceSystem
+          });
           console.warn(
             JSON.stringify({
               level: "warn",
               event: "session-kanban.mirror-failed",
               sessionId: pending2.sessionId,
               sourceSystem: pending2.sourceSystem,
-              message: error instanceof Error ? error.message : String(error),
+              message,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             })
           );
@@ -24055,6 +24214,19 @@ function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
     }
   })();
 }
+function takeSessionMirrorFailure(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId) return void 0;
+  const key = boardKey(projectRoot, sessionId);
+  const failure = mirrorFailures.get(key);
+  if (!failure) return void 0;
+  mirrorFailures.delete(key);
+  return `Kanban mirror (${failure.sourceSystem}) failed and the board may be stale: ${failure.message}`;
+}
+function hasInFlightTodoMirror(projectRoot, sessionId) {
+  if (!projectRoot || !sessionId) return false;
+  const key = mirrorKey(projectRoot, sessionId, "session-todo");
+  return pendingMirrors.has(key) || activeMirrors.has(key);
+}
 function todoListToSerializedGraph(todos, sessionId) {
   const graphId = `todo:${sessionId}`;
   const nodes = todos.map((todo, index) => ({
@@ -24216,11 +24388,11 @@ function broadcastTodoUpdate(context, todos) {
   });
 }
 function notifyTodoUpdate(context, todos) {
-  const summary = todos.length ? todos.map((todo) => `- [${todo.status}] ${todo.content} (${todo.id})`).join("\n") : "- No active todos remain.";
+  const summary = formatTodosForModel(todos);
   const text = `[KANBAN TODO UPDATE]
 Another Kanban agent reassessed the shared board. The canonical todo list is now:
 ${summary}
-Reassess your current plan before continuing; do not rely on the initial todo snapshot.`;
+Reassess your current plan before continuing; do not rely on the initial todo snapshot. Preserve each row's <kanban board/task> binding verbatim on your next \`todo\` call \u2014 a row that loses it stops advancing its card.`;
   const state = context.state;
   if (typeof state.appendBlockToLastUserMessage === "function") {
     if (state.appendBlockToLastUserMessage({ type: "text", text })) return;
@@ -24229,6 +24401,10 @@ Reassess your current plan before continuing; do not rely on the initial todo sn
     state.appendMessage({ role: "user", content: [{ type: "text", text }] });
   }
 }
+function todosNeedingSessionMirror(todos, activeBoardId2) {
+  if (!activeBoardId2) return todos;
+  return todos.filter((todo) => todo.kanbanBoardId !== activeBoardId2 || !todo.kanbanTaskId);
+}
 function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
   queueLatestMirror(
     projectRoot,
@@ -24350,7 +24526,7 @@ function attachSessionKanbanMirror(context) {
   const configureWatcher = () => {
     const planPath = context.meta["plan.path"];
     const taskPath = context.meta["task.path"];
-    const candidate = typeof planPath === "string" && planPath ? dirname15(planPath) : typeof taskPath === "string" && taskPath ? dirname15(taskPath) : "";
+    const candidate = typeof planPath === "string" && planPath ? dirname14(planPath) : typeof taskPath === "string" && taskPath ? dirname14(taskPath) : "";
     if (!candidate || candidate === watchedDir) return;
     watcher?.close();
     watcher = null;
@@ -24375,16 +24551,9 @@ function attachSessionKanbanMirror(context) {
   const unsubscribe = context.state.onChange((change) => {
     if (change.kind === "todos_replaced" && !suppressedTodoMirrors.has(context)) {
       const snapshot = change.completedSnapshot ?? change.todos;
-      if (snapshot.length > 0 && snapshot.every(
-        (todo) => todo.kanbanBoardId === activeManagedBoardId() && Boolean(todo.kanbanTaskId)
-      )) {
-        return;
-      }
-      mirrorSessionTodosToKanban(
-        context.projectRoot,
-        change.completedSnapshot ?? change.todos,
-        sessionId()
-      );
+      const unbound = todosNeedingSessionMirror(snapshot, activeManagedBoardId());
+      if (snapshot.length > 0 && unbound.length === 0) return;
+      mirrorSessionTodosToKanban(context.projectRoot, unbound, sessionId());
       return;
     }
     if (change.kind === "meta_set" && (change.key === "plan.path" || change.key === "task.path" || change.key === "kanban")) {
@@ -24420,10 +24589,54 @@ function attachSessionKanbanMirror(context) {
   bindings.set(context, detach);
   return detach;
 }
+async function rebindSessionKanbanTask(context) {
+  const sessionId = context.session?.id;
+  if (!sessionId || !context.projectRoot) return null;
+  if (context.currentKanbanTaskId) return null;
+  let best;
+  try {
+    const snapshot = await getKanbanOrchestrationSnapshot(context.projectRoot);
+    const nowMs = Date.now();
+    for (const result of snapshot.running) {
+      const assignment = result.task.assignment;
+      if (assignment?.status !== "running") continue;
+      const expiresAt = assignment.leaseExpiresAt ? Date.parse(assignment.leaseExpiresAt) : Number.NaN;
+      if (Number.isFinite(expiresAt) && expiresAt <= nowMs) continue;
+      const entry = result.board.presence?.find(
+        (candidate) => candidate.sessionId === sessionId && candidate.taskId === result.task.id
+      );
+      if (!entry) continue;
+      if (!best || entry.lastSeenAt > best.lastSeenAt) {
+        best = { boardId: result.board.id, taskId: result.task.id, lastSeenAt: entry.lastSeenAt };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!best) return null;
+  context.setCurrentKanbanTask(best.taskId, best.boardId);
+  return { boardId: best.boardId, taskId: best.taskId };
+}
+var degradationReason;
 async function hydrateSessionKanban(context) {
   const id = context.session?.id ?? "";
   if (!id) return null;
+  try {
+    const board = await hydrateSessionKanbanBoard(context, id);
+    degradationReason = void 0;
+    return board;
+  } catch (error) {
+    degradationReason = error instanceof Error ? error.message : String(error);
+    fireAndForget("hydrate", Promise.reject(error));
+    return null;
+  }
+}
+async function hydrateSessionKanbanBoard(context, id) {
+  await rebindSessionKanbanTask(context);
   await cleanupEmptySessionKanbanBoards(context.projectRoot, id);
+  if (context.projectRoot) {
+    fireAndForget("prune-session-boards", pruneSessionBoards(context.projectRoot));
+  }
   let board = await ensureSessionKanbanBoard(context.projectRoot, id);
   if (context.todos.length) {
     board = await projectSessionTodosToKanban(context.projectRoot, context.todos, id);
@@ -24454,26 +24667,68 @@ function todoStatus(task) {
   if (status === "in_progress" || status === "review") return "in_progress";
   return "pending";
 }
-function sessionTodoFromTask(task, boardId) {
+function sessionTodoFromTask(task, board) {
+  const blockedBy = board ? blockingTitles(board, task) : [];
   return {
     id: task.origin?.taskId ?? task.id,
     content: task.title,
     status: todoStatus(task),
-    kanbanBoardId: boardId,
-    kanbanTaskId: task.id,
-    ...task.description ? { activeForm: task.description } : {}
+    ...task.description ? { activeForm: task.description } : {},
+    ...blockedBy.length ? { blockedBy } : {}
   };
 }
-function managedTodoFromTask(task, boardId) {
+function managedTodoFromTask(task, board) {
   return {
-    ...sessionTodoFromTask(task, boardId),
-    status: task.status === "completed" ? "completed" : task.status === "in_progress" ? "in_progress" : "pending"
+    ...sessionTodoFromTask(task, board),
+    kanbanBoardId: board.id,
+    kanbanTaskId: task.id
   };
 }
+function blockingTitles(board, task) {
+  return getDependencyReadinessIssues(board, task).map((issue) => {
+    const dependency = board.tasks.find((candidate) => candidate.id === issue.dependencyId);
+    if (!dependency) return `${issue.dependencyId} (missing)`;
+    return dependency.title;
+  });
+}
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function orderTasksForTodos(board, tasks) {
+  const columnOrder = new Map(board.columns.map((column) => [column.id, column.order]));
+  const baseline = [...tasks].sort(
+    (left, right) => (columnOrder.get(left.columnId) ?? 0) - (columnOrder.get(right.columnId) ?? 0) || (PRIORITY_ORDER[left.priority] ?? 2) - (PRIORITY_ORDER[right.priority] ?? 2) || left.order - right.order || left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+  );
+  const included = new Set(baseline.map((task) => task.id));
+  const remaining = new Map(baseline.map((task) => [task.id, task]));
+  const emitted = [];
+  const done = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = baseline.filter(
+      (task) => remaining.has(task.id) && (task.dependsOn ?? []).every(
+        (dependencyId) => !included.has(dependencyId) || done.has(dependencyId)
+      )
+    );
+    if (ready.length === 0) break;
+    for (const task of ready) {
+      remaining.delete(task.id);
+      done.add(task.id);
+      emitted.push(task);
+    }
+  }
+  for (const task of baseline) if (remaining.has(task.id)) emitted.push(task);
+  return emitted;
+}
 function sameTodos(left, right) {
   return left.length === right.length && left.every((todo, index) => {
     const candidate = right[index];
-    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId;
+    return candidate?.id === todo.id && candidate.content === todo.content && candidate.status === todo.status && candidate.activeForm === todo.activeForm && candidate.promotedFromPlan === todo.promotedFromPlan && candidate.promotedFromTask === todo.promotedFromTask && candidate.kanbanBoardId === todo.kanbanBoardId && candidate.kanbanTaskId === todo.kanbanTaskId && // Readiness is part of the projection: when a dependency completes,
+    // the rows are otherwise identical and the unblocking would never
+    // reach the model.
+    (candidate.blockedBy ?? []).join("\0") === (todo.blockedBy ?? []).join("\0");
   });
 }
 function applySessionKanbanBoardToTodos(context, board) {
@@ -24481,13 +24736,13 @@ function applySessionKanbanBoardToTodos(context, board) {
   if (!sessionId || sessionIdFromTags(board.tags) !== sessionId || !isOwnedSessionBoard(board.tags)) {
     return [...context.todos];
   }
-  const projectedTodos = board.tasks.filter(
-    (task) => task.status !== "archived" && (!task.origin || task.origin.system === "session-todo" || (task.origin.graphId ?? "").startsWith("todo:"))
-  ).sort((left, right) => {
-    const leftColumn = board.columns.find((column) => column.id === left.columnId)?.order ?? 0;
-    const rightColumn = board.columns.find((column) => column.id === right.columnId)?.order ?? 0;
-    return leftColumn - rightColumn || left.order - right.order || left.createdAt.localeCompare(right.createdAt);
-  }).map((task) => sessionTodoFromTask(task, board.id));
+  if (hasInFlightTodoMirror(context.projectRoot, sessionId)) return [...context.todos];
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && (!task.origin || task.origin.system === "session-todo" || (task.origin.graphId ?? "").startsWith("todo:"))
+    )
+  ).map((task) => sessionTodoFromTask(task, board));
   const allCompleted = projectedTodos.length > 0 && projectedTodos.every((todo) => todo.status === "completed");
   const effectiveTodos = allCompleted ? [] : projectedTodos;
   if (sameTodos(context.todos, effectiveTodos)) return [...context.todos];
@@ -24508,11 +24763,12 @@ function applyManagedKanbanBoardToTodos(context, board) {
   if (!activeBoardId2 || board.id !== activeBoardId2 || board.lifecycle?.mode !== "managed") {
     return [...context.todos];
   }
-  const projectedTodos = board.tasks.filter(
-    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
-  ).sort(
-    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
-  ).map((task) => managedTodoFromTask(task, board.id));
+  const projectedTodos = orderTasksForTodos(
+    board,
+    board.tasks.filter(
+      (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+    )
+  ).map((task) => managedTodoFromTask(task, board));
   if (sameTodos(context.todos, projectedTodos)) return [...context.todos];
   suppressedTodoMirrors.add(context);
   try {
@@ -24547,7 +24803,11 @@ async function applySessionKanbanTaskToSource(context, task, options = {}) {
   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" };
+    if (typeof planPath !== "string" || !planPath) {
+      throw new Error(
+        "Cannot reflect this Kanban edit back to its plan source: the session has no plan.path configured. The board mutation already succeeded; the plan file is now out of sync."
+      );
+    }
     const plan = await mutatePlan(planPath, id, (file) => ({
       ...file,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24565,7 +24825,11 @@ async function applySessionKanbanTaskToSource(context, task, options = {}) {
   }
   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" };
+    if (typeof taskPath !== "string" || !taskPath) {
+      throw new Error(
+        "Cannot reflect this Kanban edit back to its task source: the session has no task.path configured. The board mutation already succeeded; the task file is now out of sync."
+      );
+    }
     const tasks = await mutateTasks(taskPath, id, (file) => ({
       ...file,
       tasks: options.remove ? file.tasks.filter((item) => item.id !== originId) : file.tasks.map(
@@ -24614,8 +24878,14 @@ var kanbanTool = {
           }
           case "create_board": {
             if (!input.title) return fail("create_board requires title.");
+            const existing = (await listBoards2(projectRoot)).filter(
+              (candidate) => (candidate.kind ?? "project") === "project"
+            );
             const board = await createBoard2(projectRoot, boardCreateInput(input, input.title));
-            return { ok: true, message: `Board created: ${board.title}`, board };
+            const note = existing.length ? ` ${existing.length} other project board(s) already exist: ${existing.slice(0, 3).map((candidate) => `"${candidate.title}" (${candidate.taskCount} task(s))`).join(
+              ", "
+            )}${existing.length > 3 ? ", \u2026" : ""}. If this work belongs to one of them, add_task there instead and delete this board.` : "";
+            return { ok: true, message: `Board created: ${board.title}.${note}`, board };
           }
           case "update_board": {
             if (!input.boardId) return fail("update_board requires boardId.");
@@ -24644,6 +24914,20 @@ var kanbanTool = {
             });
             return board ? okBoard(board, "Managed lifecycle adopted without moving existing cards.") : fail("Board not found.");
           }
+          // Adoption used to be a one-way door: the strict lifecycle carries
+          // acceptance-criteria, verification-report, review-evidence and
+          // one-stage-at-a-time gates, and nothing on the tool surface could
+          // undo it, so a board adopted once kept its ceremony forever. The
+          // gates are worth having where a fleet is supervised; they are not
+          // worth being unable to leave. Cards and columns are untouched.
+          case "release_managed_lifecycle": {
+            if (!input.boardId) return fail("release_managed_lifecycle requires boardId.");
+            const board = await updateBoard2(projectRoot, input.boardId, { lifecycle: null });
+            return board ? okBoard(
+              board,
+              "Managed lifecycle released; the board now tracks work without strict gates."
+            ) : fail("Board not found.");
+          }
           case "duplicate_board": {
             if (!input.boardId) return fail("duplicate_board requires boardId.");
             const board = await duplicateBoard(
@@ -24663,8 +24947,7 @@ var kanbanTool = {
             const boardInput = createBoardFromText({
               description: input.description,
               ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.context !== void 0 ? { context: input.context } : {},
-              ...input.columns !== void 0 ? { columns: input.columns } : {}
+              ...input.context !== void 0 ? { context: input.context } : {}
             });
             const board = await createBoard2(projectRoot, boardInput);
             for (const taskInput2 of parseLinesIntoTasks(
@@ -24802,7 +25085,7 @@ var kanbanTool = {
             return { ok: true, message: `${tasks.length} ready task(s).`, tasks };
           }
           case "snapshot": {
-            const snapshot = await getKanbanOrchestrationSnapshot(projectRoot, {
+            const snapshot = await getKanbanOrchestrationSnapshot2(projectRoot, {
               query: input.query,
               boardId: input.boardId,
               assignedAgent: input.agentId,
@@ -24817,33 +25100,6 @@ var kanbanTool = {
               snapshot
             };
           }
-          case "add_column": {
-            if (!input.boardId || !input.title)
-              return fail("add_column requires boardId and title.");
-            const result2 = await addColumn(projectRoot, input.boardId, {
-              title: input.title,
-              ...input.description !== void 0 ? { description: input.description } : {}
-            });
-            return result2 ? okBoard(result2.board, "Column added.") : fail("Board not found.");
-          }
-          case "update_column": {
-            if (!input.boardId || !input.columnId)
-              return fail("update_column requires boardId and columnId.");
-            const board = await updateColumn(projectRoot, input.boardId, input.columnId, {
-              ...input.title !== void 0 ? { title: input.title } : {},
-              ...input.description !== void 0 ? { description: input.description } : {},
-              ...input.order !== void 0 ? { order: input.order } : {}
-            });
-            return board ? okBoard(board, "Column updated.") : fail("Column not found.");
-          }
-          case "delete_column": {
-            if (!input.boardId || !input.columnId)
-              return fail("delete_column requires boardId and columnId.");
-            const board = await removeColumn(projectRoot, input.boardId, input.columnId, {
-              moveTasksToColumnId: input.moveTasksToColumnId
-            });
-            return board ? okBoard(board, "Column deleted.") : fail("Column not found.");
-          }
           case "add_task": {
             if (!input.boardId || !input.title) return fail("add_task requires boardId and title.");
             const result2 = await addTask(projectRoot, input.boardId, taskInput(input));
@@ -24925,6 +25181,32 @@ var kanbanTool = {
                 `Task is not implementation-ready: ${readiness.issues.map((issue) => issue.message).join(" | ")}`
               );
             }
+            if (board.lifecycle?.mode !== "managed") {
+              const now2 = /* @__PURE__ */ new Date();
+              const assigned = await updateTaskAssignment(projectRoot, board.id, task.id, {
+                status: "running",
+                agentId: input.agentId ?? input.author,
+                leaseId: input.leaseId ?? randomUUID2(),
+                claimedAt: input.claimedAt ?? now2.toISOString(),
+                heartbeatAt: input.heartbeatAt ?? now2.toISOString(),
+                leaseExpiresAt: input.leaseExpiresAt ?? new Date(now2.getTime() + 15 * 6e4).toISOString(),
+                attempt: input.attempt ?? 1,
+                maxAttempts: input.maxAttempts ?? 3
+              });
+              if (!assigned) return fail("Task assignment could not be started.");
+              const started = await updateTask2(projectRoot, board.id, task.id, {
+                status: "in_progress"
+              });
+              const current = started ?? assigned;
+              const claimed = task;
+              const currentTask = current.tasks.find((candidate) => candidate.id === claimed.id) ?? claimed;
+              ctx.setCurrentKanbanTask?.(currentTask.id, current.id);
+              return okTask(
+                current,
+                currentTask,
+                "Task is active and bound to this run for attribution. This board is not in managed lifecycle mode, so runtime Kanban governance was not bound to it."
+              );
+            }
             let stage = task.lifecycle?.currentStage;
             if (stage === "backlog") {
               const moved = await transitionTask(projectRoot, board.id, task.id, {
@@ -25065,6 +25347,9 @@ var kanbanTool = {
             if (!input.boardId || !input.taskId)
               return fail("delete_task requires boardId and taskId.");
             const board = await removeTask(projectRoot, input.boardId, input.taskId);
+            if (board && ctx.currentKanbanTaskId === input.taskId) {
+              ctx.setCurrentKanbanTask?.(void 0, ctx.currentKanbanBoardId);
+            }
             return board ? okBoard(board, "Task deleted.") : fail("Task not found.");
           }
           case "set_chain": {
@@ -25197,7 +25482,7 @@ var kanbanTool = {
                   });
                 } catch (err) {
                   lifecycleWarnings.push(
-                    `Lifecycle transition to Running deferred: ${err instanceof Error ? err.message : String(err)}`
+                    `Lifecycle transition to Running deferred: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
               }
@@ -25221,7 +25506,7 @@ var kanbanTool = {
                   });
                 } catch (err) {
                   lifecycleWarnings.push(
-                    `Lifecycle transition to Review failed: ${err instanceof Error ? err.message : String(err)}`
+                    `Lifecycle transition to Review failed: ${stripLifecycleIssues(err instanceof Error ? err.message : String(err))}`
                   );
                 }
                 if (transitionResult) {
@@ -25241,7 +25526,11 @@ var kanbanTool = {
                         successCriteria: verResult.task.successCriteria
                       });
                       const verdict = verResult.report.verdict;
-                      if (verdict === "passed") {
+                      if (verdict === "passed" && !resolveAutoAccept(board)) {
+                        lifecycleWarnings.push(
+                          "Verification passed, but this board does not auto-accept. The card is in Review awaiting an explicit transition_task to done."
+                        );
+                      } else if (verdict === "passed") {
                         try {
                           const doneResult = await transitionTask(
                             projectRoot,
@@ -25359,11 +25648,34 @@ var kanbanTool = {
             });
             return {
               ok: true,
-              message: `Counts: ready=${health.counts.ready}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
+              message: `Counts: startable=${health.counts.startable}, running=${health.counts.running}, stale=${health.staleAssignments.count}.`,
               queueHealth: health
             };
           }
+          // Not every action is handled above. These are dispatched from here,
+          // and the split has already cost real time: an agent that read this
+          // file concluded `add_check` / `update_check` did not exist, wrote
+          // that on a card, and spent a session trying to satisfy a gate it
+          // already had the tool to clear. Keep this index in step with the
+          // handlers.
+          //
+          //   kanban-detail-actions.ts  workbench · add_dependency ·
+          //     add_goal_metric · update_goal_metric · add_check ·
+          //     update_check · add_note · add_link · split_atomic
+          //   kanban-decomposition-actions.ts  verify_completion ·
+          //     assess_atomicity · propose_decomposition
+          //   kanban-contract-actions.ts  get_contract_graph ·
+          //     configure_contract_graph · upsert_contract_node ·
+          //     remove_contract_node · add_contract_edge · remove_contract_edge
           default:
+            {
+              const contractResult = await handleKanbanContractAction(
+                projectRoot,
+                input,
+                input.author ?? input.agentId
+              );
+              if (contractResult !== void 0) return contractResult;
+            }
             {
               const detailResult = await handleKanbanDetailAction(projectRoot, input);
               if (detailResult !== void 0) return detailResult;
@@ -25373,7 +25685,7 @@ var kanbanTool = {
       })();
       return withPresence(result);
     } catch (err) {
-      return fail(err instanceof Error ? err.message : String(err));
+      return fail(stripLifecycleIssues(err instanceof Error ? err.message : String(err)));
     }
   }
 };
@@ -26226,7 +26538,7 @@ import {
   saveTasks,
   setPlanItemStatus
 } from "@wrongstack/core/storage";
-import { getBoard as getBoard4 } from "@wrongstack/kanban";
+import { addTask as addTask2, getBoard as getBoard4 } from "@wrongstack/kanban";
 function normalizedTitle(value) {
   return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
 }
@@ -26254,11 +26566,51 @@ function bindTodosToBoard(items, previous, board) {
       available.find((task2) => !used.has(task2.id) && normalizedTitle(task2.title) === title)
     ];
     const task = candidates.find((candidate) => candidate && !used.has(candidate.id));
-    if (!task) return { ...item };
+    if (!task) {
+      const { blockedBy: _discarded, ...rest } = item;
+      return { ...rest };
+    }
     used.add(task.id);
-    return { ...item, kanbanBoardId: board.id, kanbanTaskId: task.id };
+    const blockedBy = blockingTitles(board, task);
+    return {
+      ...item,
+      kanbanBoardId: board.id,
+      kanbanTaskId: task.id,
+      ...blockedBy.length ? { blockedBy } : { blockedBy: void 0 }
+    };
   });
 }
+function demoteBlockedInProgress(items, warnings) {
+  return items.map((item) => {
+    if (item.status !== "in_progress" || !item.blockedBy?.length) return item;
+    warnings.push(
+      `"${item.content}" cannot start yet \u2014 it waits on: ${item.blockedBy.join("; ")}. Kept as pending; complete the blocking work first.`
+    );
+    return { ...item, status: "pending" };
+  });
+}
+async function createMissingManagedCards(items, board, ctx, warnings) {
+  const created = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
+    try {
+      const result = await addTask2(ctx.projectRoot, board.id, {
+        title: item.content,
+        description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
+      });
+      if (!result) {
+        warnings.push(`Could not open a Kanban card for "${item.content}": board not found.`);
+        continue;
+      }
+      created.set(item.id, result.task.id);
+    } catch (error) {
+      warnings.push(
+        `Could not open a Kanban card for "${item.content}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return created;
+}
 async function synchronizeManagedKanban(items, board, ctx, signal) {
   let synced = 0;
   const warnings = [];
@@ -26296,6 +26648,16 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
       transitionComment: `Todo returned to queue: ${item.content}`
     });
   }
+  for (const item of items) {
+    if (item.status === "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.status !== "completed") continue;
+    warnings.push(
+      `"${item.content}" is already Done on the Kanban board and a completed card cannot be reopened; the row stays completed. Create a follow-up card for any remaining work.`
+    );
+  }
   for (const item of items) {
     if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
       continue;
@@ -26347,17 +26709,25 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
   const active = items.find(
     (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
   );
+  const activeStage = active?.kanbanTaskId ? afterCompletions?.tasks.find((task) => task.id === active.kanbanTaskId)?.lifecycle?.currentStage : void 0;
   if (active?.kanbanTaskId) {
-    await execute({
-      action: "start_task",
-      boardId: board.id,
-      taskId: active.kanbanTaskId,
-      author: actor,
-      agentId: actor,
-      transitionComment: `Todo activated: ${active.content}`
-    });
+    if (activeStage === "review" || activeStage === "done") {
+      warnings.push(
+        `"${active.content}" is in ${activeStage === "review" ? "Review" : "Done"} awaiting acceptance; not re-activating it from the todo list. ` + (activeStage === "review" ? "Call kanban start_task explicitly to reopen it as a repair." : "Done is terminal; reopen only by creating a follow-up card.")
+      );
+    } else {
+      await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: active.kanbanTaskId,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Todo activated: ${active.content}`
+      });
+    }
   }
-  if (active?.kanbanTaskId && completionPending) {
+  if (active?.kanbanTaskId && activeStage === "review") {
+  } else if (active?.kanbanTaskId && completionPending) {
     warnings.push(
       "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
     );
@@ -26444,29 +26814,47 @@ var todoTool = {
       }
     }
     const boardId = activeBoardId(items, ctx);
-    const board = boardId ? await getBoard4(ctx.projectRoot, boardId) : null;
-    const boundItems = board?.lifecycle?.mode === "managed" ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    let board = boardId ? await getBoard4(ctx.projectRoot, boardId) : null;
+    const managed = board?.lifecycle?.mode === "managed";
+    let boundItems = managed && board ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    const creationWarnings = [];
+    if (managed && board) {
+      const managedBoardId = board.id;
+      const created = await createMissingManagedCards(boundItems, board, ctx, creationWarnings);
+      if (created.size > 0) {
+        boundItems = boundItems.map((item) => {
+          const taskId = created.get(item.id);
+          return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
+        });
+        board = await getBoard4(ctx.projectRoot, managedBoardId) ?? board;
+        boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
+      }
+      boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
+    }
     ctx.state.replaceTodos(boundItems);
-    const kanbanSync = board?.lifecycle?.mode === "managed" ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
-    if (board?.lifecycle?.mode === "managed") {
+    const kanbanSync = managed && board ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
+    kanbanSync.warnings.unshift(...creationWarnings);
+    if (managed && board) {
       const unresolved = boundItems.filter(
         (item) => item.kanbanBoardId !== board.id || !item.kanbanTaskId
       );
       if (unresolved.length > 0) {
         kanbanSync.warnings.push(
-          `${unresolved.length} Todo row(s) did not match a real Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
+          `${unresolved.length} Todo row(s) could not be bound to a Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
         );
       }
     }
+    const mirrorFailure = takeSessionMirrorFailure(ctx.projectRoot, ctx.session?.id ?? "");
+    if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
     let projectedBoard = board;
-    if (board?.lifecycle?.mode === "managed") {
+    if (managed && board) {
       const refreshed = await getBoard4(ctx.projectRoot, board.id);
       if (refreshed) {
         projectedBoard = refreshed;
         applyManagedKanbanBoardToTodos(ctx, refreshed);
       }
     }
-    if (board?.lifecycle?.mode !== "managed") {
+    if (!managed) {
       mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
     }
     const completedPlanIds = /* @__PURE__ */ new Set();
@@ -29502,6 +29890,7 @@ var OPTIONAL_TOOLS = [
   toolHelpTool,
   setWorkingDirTool
 ];
+var OFF_ONLY_TOOLS = [...browserTools, e2ePlanTool];
 var TIER1_TOOLS = [
   readTool,
   writeTool,
@@ -30983,6 +31372,7 @@ export {
   IndexCircuitBreaker,
   IndexTimeoutError,
   LanguageProfileRegistry,
+  OFF_ONLY_TOOLS,
   OPTIONAL_TOOLS,
   PRIMARY_LANGUAGE_PROFILES,
   SESSION_KANBAN_COLUMNS,
@@ -31102,6 +31492,7 @@ export {
   projectSessionTasksToKanban,
   projectSessionTodosToKanban,
   readTool,
+  rebindSessionKanbanTask,
   recordKanbanVerificationEvidence,
   redactBrowserText,
   registerBuiltinToolTier,