@wrongstack/core 0.303.0 → 0.305.0

package/dist/utils/index.js

@@ -724,17 +724,17 @@ async function updateJsonObjectFile(filePath, mutator) {
 function isForbiddenSegment(segment) {
   return typeof segment === "string" && FORBIDDEN_PROTO_KEYS.has(segment);
 }
-function assertSafePath(path11) {
-  for (const segment of path11) {
+function assertSafePath(path12) {
+  for (const segment of path12) {
     if (isForbiddenSegment(segment)) {
       throw new Error(`Refusing to use reserved key "${String(segment)}" in a JSON path`);
     }
   }
 }
-function getJsonPath(root, path11) {
-  if (path11.some(isForbiddenSegment)) return void 0;
+function getJsonPath(root, path12) {
+  if (path12.some(isForbiddenSegment)) return void 0;
   let current = root;
-  for (const segment of path11) {
+  for (const segment of path12) {
     if (typeof segment === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[segment];
@@ -745,14 +745,14 @@ function getJsonPath(root, path11) {
   }
   return current;
 }
-function setJsonPath(root, path11, value) {
-  assertSafePath(path11);
-  if (path11.length === 0) {
+function setJsonPath(root, path12, value) {
+  assertSafePath(path12);
+  if (path12.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path11);
-  const leaf = lastPathSegment(path11);
+  const parent = ensureJsonParent(root, path12);
+  const leaf = lastPathSegment(path12);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent))
       throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
@@ -763,11 +763,11 @@ function setJsonPath(root, path11, value) {
   }
   return root;
 }
-function removeJsonPath(root, path11) {
-  if (path11.some(isForbiddenSegment)) return false;
-  if (path11.length === 0) return false;
-  const parent = getJsonPath(root, path11.slice(0, -1));
-  const leaf = lastPathSegment(path11);
+function removeJsonPath(root, path12) {
+  if (path12.some(isForbiddenSegment)) return false;
+  if (path12.length === 0) return false;
+  const parent = getJsonPath(root, path12.slice(0, -1));
+  const leaf = lastPathSegment(path12);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent) || leaf < 0 || leaf >= parent.length) return false;
     parent.splice(leaf, 1);
@@ -777,28 +777,28 @@ function removeJsonPath(root, path11) {
   delete parent[leaf];
   return true;
 }
-async function setJsonPathInFile(filePath, path11, value) {
-  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path11, value));
+async function setJsonPathInFile(filePath, path12, value) {
+  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path12, value));
 }
-async function removeJsonPathInFile(filePath, path11) {
+async function removeJsonPathInFile(filePath, path12) {
   return updateJsonObjectFile(filePath, (config) => {
-    removeJsonPath(config, path11);
+    removeJsonPath(config, path12);
   });
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path11) {
-  const segment = path11[path11.length - 1];
+function lastPathSegment(path12) {
+  const segment = path12[path12.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path11) {
-  assertSafePath(path11);
+function ensureJsonParent(root, path12) {
+  assertSafePath(path12);
   let current = root;
-  for (let i = 0; i < path11.length - 1; i += 1) {
-    const segment = path11[i];
-    const nextSegment = path11[i + 1];
+  for (let i = 0; i < path12.length - 1; i += 1) {
+    const segment = path12[i];
+    const nextSegment = path12[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
@@ -1361,6 +1361,37 @@ function isEmptyMessage(msg) {
   return !hasMeaningfulContent(msg.content);
 }
 
+// src/utils/todos-format.ts
+function formatTodosList(todos) {
+  if (todos.length === 0) return "No todos.";
+  const lines = [];
+  const done = todos.filter((t) => t.status === "completed").length;
+  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
+  todos.forEach((t, i) => {
+    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
+    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
+    const label = t.status === "completed" ? color.dim(text) : text;
+    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
+  });
+  return lines.join("\n");
+}
+function formatTodoForModel(todo) {
+  const binding = todo.kanbanBoardId && todo.kanbanTaskId ? ` <kanban ${todo.kanbanBoardId}/${todo.kanbanTaskId}>` : "";
+  const blocked = todo.blockedBy?.length ? ` [blocked by: ${todo.blockedBy.join("; ")}]` : "";
+  return `- [${todo.status}]${blocked} ${todo.content} (${todo.id})${binding}`;
+}
+function formatTodosForModel(todos, emptyLine = "- No active todos remain.") {
+  return todos.length ? todos.map(formatTodoForModel).join("\n") : emptyLine;
+}
+function hasKanbanBoundTodos(todos) {
+  if (!Array.isArray(todos)) return false;
+  return todos.some((todo) => Boolean(todo.kanbanBoardId && todo.kanbanTaskId));
+}
+function hasOpenTodos(todos) {
+  if (!Array.isArray(todos) || todos.length === 0) return false;
+  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
+}
+
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -1675,25 +1706,6 @@ function resetCalibration(calibrationKey) {
   _cals.delete(calibrationKey);
 }
 
-// src/utils/todos-format.ts
-function formatTodosList(todos) {
-  if (todos.length === 0) return "No todos.";
-  const lines = [];
-  const done = todos.filter((t) => t.status === "completed").length;
-  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
-  todos.forEach((t, i) => {
-    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
-    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
-    const label = t.status === "completed" ? color.dim(text) : text;
-    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
-  });
-  return lines.join("\n");
-}
-function hasOpenTodos(todos) {
-  if (!Array.isArray(todos) || todos.length === 0) return false;
-  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
-}
-
 // src/core/agent-response.ts
 var MAX_TODO_SNAPSHOT_ITEMS = 10;
 var MAX_TODO_SNAPSHOT_CONTENT = 180;
@@ -1725,12 +1737,15 @@ function buildLiveNextStepsGateBlock(ctx) {
   const todoSnapshot = openTodos.slice(0, MAX_TODO_SNAPSHOT_ITEMS).map((todo) => {
     const normalized = todo.content.replace(/\s+/g, " ").trim();
     const content = normalized.length > MAX_TODO_SNAPSHOT_CONTENT ? `${normalized.slice(0, MAX_TODO_SNAPSHOT_CONTENT - 1)}\u2026` : normalized;
-    return `- [${todo.status}] ${content}`;
+    return formatTodoForModel({ ...todo, content });
   });
   const omitted = openTodos.length - todoSnapshot.length;
   if (omitted > 0) todoSnapshot.push(`- \u2026and ${omitted} more open todo(s)`);
   const todoReconciliation = ctx.tools?.some((tool) => tool.name === "todo") ? [
-    "Before ending the turn, you MUST call the `todo` tool with the complete current list to reconcile actual progress: finished items completed, exactly one actively worked item in_progress, and untouched items pending. A prose claim that work is done does not update the Todo/Kanban state."
+    "Before ending the turn, you MUST call the `todo` tool with the complete current list to reconcile actual progress: finished items completed, exactly one actively worked item in_progress, and untouched items pending. A prose claim that work is done does not update the Todo/Kanban state.",
+    ...hasKanbanBoundTodos(openTodos) ? [
+      "Rows below carry a <kanban board/task> binding. Pass those exact ids back as `kanbanBoardId`/`kanbanTaskId` on every row you resend; a row that arrives without its binding is not applied to its card."
+    ] : []
   ] : [];
   return {
     type: "text",
@@ -2222,8 +2237,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat3 = await fsp.stat(full);
-          if (stat3.isDirectory()) await walk2(full, rest);
+          const stat4 = await fsp.stat(full);
+          if (stat4.isDirectory()) await walk2(full, rest);
         } catch {
         }
       }
@@ -2240,8 +2255,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat3 = await fsp.stat(full);
-          if (stat3.isDirectory()) await walk2(full, rest);
+          const stat4 = await fsp.stat(full);
+          if (stat4.isDirectory()) await walk2(full, rest);
         } catch {
         }
       }
@@ -2664,8 +2679,8 @@ async function pruneOldSessions(root, currentDir) {
   const sessions = await Promise.all(
     entries.filter((entry) => entry.isDirectory() && entry.name !== path4.basename(currentDir)).map(async (entry) => {
       const fullPath = path4.join(root, entry.name);
-      const stat3 = await fsp2.stat(fullPath);
-      return { fullPath, mtimeMs: stat3.mtimeMs };
+      const stat4 = await fsp2.stat(fullPath);
+      return { fullPath, mtimeMs: stat4.mtimeMs };
     })
   );
   sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -3509,10 +3524,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path11, errors, depth) {
+function walk(value, schema, path12, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path11 || "<root>",
+      path: path12 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -3520,7 +3535,7 @@ function walk(value, schema, path11, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path11 || "<root>",
+        path: path12 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3529,7 +3544,7 @@ function walk(value, schema, path11, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path11 || "<root>",
+        path: path12 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -3541,7 +3556,7 @@ function walk(value, schema, path11, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path11, req),
+          path: joinPath(path12, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -3549,14 +3564,14 @@ function walk(value, schema, path11, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path11, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path12, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path11}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path12}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -4061,24 +4076,133 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 
-// src/utils/project-watch.ts
+// src/utils/project-state-guard.ts
 import * as fs6 from "node:fs";
+import * as fsp4 from "node:fs/promises";
 import * as path9 from "node:path";
-var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("wrongstack.projectWatchRegistry");
+var PROJECT_STATE_DIRECTORY = ".wrongstack";
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+var REPAIR_DEBOUNCE_MS = 25;
+var ACTIVE_GUARD_KEY = /* @__PURE__ */ Symbol.for("wrongstack.activeProjectStateGuard");
 var globalScope = globalThis;
-if (!globalScope[REGISTRY_KEY]) globalScope[REGISTRY_KEY] = /* @__PURE__ */ new Map();
-var registry = globalScope[REGISTRY_KEY];
-function registryKey(root) {
+globalScope[ACTIVE_GUARD_KEY] ??= {};
+var activeGuard = globalScope[ACTIVE_GUARD_KEY];
+function normalizedRoot(root) {
   const resolved = path9.resolve(root);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
+function concernsProjectState(filename) {
+  if (filename === null) return true;
+  const firstSegment = String(filename).replaceAll("\\", "/").split("/")[0];
+  return firstSegment?.toLowerCase() === PROJECT_STATE_DIRECTORY;
+}
+async function startProjectStateGuard(projectRoot, options = {}) {
+  const root = path9.resolve(projectRoot);
+  const directory = path9.join(root, PROJECT_STATE_DIRECTORY);
+  const pollIntervalMs = Math.max(25, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  let closed = false;
+  let repairPending = false;
+  let repairInFlight;
+  let repairTimer;
+  const ensureDirectory = async () => {
+    await fsp4.mkdir(directory, { recursive: true });
+  };
+  const ensureInvariant = async () => {
+    await ensureDirectory();
+    try {
+      await ensureProjectGitignore(root);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const scheduleRepair = () => {
+    if (closed) return;
+    repairPending = true;
+    if (repairInFlight || repairTimer) return;
+    repairTimer = setTimeout(() => {
+      repairTimer = void 0;
+      repairInFlight = (async () => {
+        while (!closed && repairPending) {
+          repairPending = false;
+          try {
+            const rootState = await fsp4.stat(root).catch(() => void 0);
+            if (!rootState?.isDirectory()) return;
+            await ensureInvariant();
+          } catch (error) {
+            options.onError?.(error);
+          }
+        }
+      })().finally(() => {
+        repairInFlight = void 0;
+        if (repairPending && !closed) scheduleRepair();
+      });
+    }, REPAIR_DEBOUNCE_MS);
+    repairTimer.unref?.();
+  };
+  await ensureDirectory();
+  await ensureProjectGitignore(root).catch((error) => options.onError?.(error));
+  let watcher;
+  try {
+    watcher = fs6.watch(root, { persistent: false }, (_eventType, filename) => {
+      if (concernsProjectState(filename) || String(filename).toLowerCase() === ".gitignore") {
+        scheduleRepair();
+      }
+    });
+    watcher.on("error", (error) => {
+      options.onError?.(error);
+      watcher = void 0;
+      scheduleRepair();
+    });
+  } catch (error) {
+    options.onError?.(error);
+  }
+  const poll = setInterval(scheduleRepair, pollIntervalMs);
+  poll.unref?.();
+  return {
+    directory,
+    close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(poll);
+      if (repairTimer) clearTimeout(repairTimer);
+      repairTimer = void 0;
+      try {
+        watcher?.close();
+      } catch {
+      }
+      watcher = void 0;
+    }
+  };
+}
+async function activateProjectStateGuard(projectRoot, options = {}) {
+  const root = normalizedRoot(projectRoot);
+  if (activeGuard.root === root && activeGuard.guard) return activeGuard.guard;
+  const next = await startProjectStateGuard(projectRoot, options);
+  const previous = activeGuard.guard;
+  activeGuard.root = root;
+  activeGuard.guard = next;
+  previous?.close();
+  return next;
+}
+
+// src/utils/project-watch.ts
+import * as fs7 from "node:fs";
+import * as path10 from "node:path";
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("wrongstack.projectWatchRegistry");
+var globalScope2 = globalThis;
+if (!globalScope2[REGISTRY_KEY]) globalScope2[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+var registry = globalScope2[REGISTRY_KEY];
+function registryKey(root) {
+  const resolved = path10.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
 function watchProjectTree(root, listener, opts) {
   const key = registryKey(root);
   let entry = registry.get(key);
   if (!entry || entry.dead) {
     const subscribers = /* @__PURE__ */ new Set();
-    const watcher = fs6.watch(
-      path9.resolve(root),
+    const watcher = fs7.watch(
+      path10.resolve(root),
       { recursive: true, persistent: false },
       (eventType, filename) => {
         const event = {
@@ -4394,14 +4518,14 @@ function stripJsonComments(s) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path10.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path10.relative(path10.resolve(dir), resolved);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
+  const resolved = path11.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path11.relative(path11.resolve(dir), resolved);
+  if (rel.startsWith("..") || path11.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -4417,7 +4541,7 @@ function invalid(sessionId) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/utils/slug.ts
@@ -4678,20 +4802,29 @@ function findWordBoundary(text, limit) {
 }
 
 // src/utils/tool-name.ts
+import { createHash as createHash3 } from "node:crypto";
 var WIRE_TOOL_NAME_MAX_LENGTH = 128;
 var WIRE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+var MCP_SERVER_SEGMENT_MAX_LENGTH = 48;
+var MCP_IDENTITY_HASH_LENGTH = 10;
 function sanitizeWireToolName(name) {
   const replaced = name.replace(/[^a-zA-Z0-9_-]/g, "_");
   const clamped = replaced.slice(0, WIRE_TOOL_NAME_MAX_LENGTH);
   return clamped.length > 0 ? clamped : "tool";
 }
+function collisionSafeMcpSegment(value, maxLength) {
+  const replaced = value.replace(/[^a-zA-Z0-9_-]/g, "_") || "tool";
+  if (replaced === value && replaced.length <= maxLength) return replaced;
+  const suffix = `_${createHash3("sha256").update(value, "utf8").digest("hex").slice(0, MCP_IDENTITY_HASH_LENGTH)}`;
+  return `${replaced.slice(0, Math.max(1, maxLength - suffix.length))}${suffix}`;
+}
 function mcpServerToolPrefix(serverName) {
-  return `mcp__${sanitizeWireToolName(serverName)}__`;
+  return `mcp__${collisionSafeMcpSegment(serverName, MCP_SERVER_SEGMENT_MAX_LENGTH)}__`;
 }
 function mcpQualifiedToolName(serverName, toolName) {
-  return sanitizeWireToolName(
-    `${mcpServerToolPrefix(serverName)}${sanitizeWireToolName(toolName)}`
-  );
+  const prefix = mcpServerToolPrefix(serverName);
+  const toolSegment = collisionSafeMcpSegment(toolName, WIRE_TOOL_NAME_MAX_LENGTH - prefix.length);
+  return `${prefix}${toolSegment}`;
 }
 
 // src/utils/tool-output-serializer.ts
@@ -5599,6 +5732,7 @@ export {
   TerminalLifecycle,
   WIRE_TOOL_NAME_MAX_LENGTH,
   WIRE_TOOL_NAME_PATTERN,
+  activateProjectStateGuard,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -5664,6 +5798,8 @@ export {
   formatCompletedWorkLedger,
   formatTaskList,
   formatTaskProgress,
+  formatTodoForModel,
+  formatTodosForModel,
   formatTodosList,
   getCalibrationState,
   getChildEnvGitIdentity,
@@ -5672,6 +5808,7 @@ export {
   getPerfProfile,
   getToolDescriptionMode,
   getToolResultRenderMode,
+  hasKanbanBoundTodos,
   hasMeaningfulContent,
   hasOpenTodos,
   indexParallelBatchSize,
@@ -5750,6 +5887,7 @@ export {
   splitSageOutputBlock,
   sqliteCachePragmas,
   startHeapWatchdog,
+  startProjectStateGuard,
   startSharedHeapWatchdog,
   stripAnsi,
   stripCodeFences,

package/dist/utils/project-state-guard.d.ts

@@ -0,0 +1,21 @@
+export interface ProjectStateGuard {
+    readonly directory: string;
+    close(): void;
+}
+export interface ProjectStateGuardOptions {
+    /** Fallback for platforms/filesystems that drop watch events. */
+    pollIntervalMs?: number | undefined;
+    onError?: ((error: unknown) => void) | undefined;
+}
+/**
+ * Keep the active project's state directory present for the lifetime of a
+ * runtime. The root watcher repairs direct deletion immediately; an unref'ed
+ * poll covers filesystems where watch events are lossy or unsupported.
+ */
+export declare function startProjectStateGuard(projectRoot: string, options?: ProjectStateGuardOptions): Promise<ProjectStateGuard>;
+/**
+ * Activate the process-wide guard for one project. Switching projects closes
+ * the previous guard only after the next directory has been established.
+ */
+export declare function activateProjectStateGuard(projectRoot: string, options?: ProjectStateGuardOptions): Promise<ProjectStateGuard>;
+//# sourceMappingURL=project-state-guard.d.ts.map

package/dist/utils/session-scoped-path.d.ts

@@ -10,4 +10,21 @@
  * several stores ended up throwing on every modern session id.
  */
 export declare function sessionScopedPath(dir: string, sessionId: string, suffix: string): string;
+/**
+ * True when a file name in the sessions directory is a session transcript.
+ *
+ * Every directory scan needs this, and each one used to answer it for itself:
+ * `SessionRecovery` filtered sidecars, the store's `collectSessionIds` /
+ * `collectSessionFiles` did not, and the catalog daemon's `rebuildCatalog`
+ * excluded `_index.jsonl` alone. The scans that did not filter turned every
+ * sidecar into a phantom session — `sess_x.replay` and `_mailbox` were listed
+ * next to `sess_x` in the picker, written into `_index.jsonl` by
+ * `rebuildIndex()`, and counted as candidates by prefix resolution, so a
+ * session id that had been unique became an ambiguous prefix as soon as the
+ * session recorded a replay log.
+ *
+ * One predicate, so a new sidecar suffix cannot be added to one scanner's
+ * blocklist and forgotten in the others.
+ */
+export declare function isSessionTranscriptFileName(name: string): boolean;
 //# sourceMappingURL=session-scoped-path.d.ts.map

package/dist/utils/todos-format.d.ts

@@ -13,6 +13,26 @@ import type { TodoItem } from '../core/context.js';
  * straight to a history dispatcher or stdout.
  */
 export declare function formatTodosList(todos: TodoItem[]): string;
+/**
+ * Render one todo row for the model, including its Kanban binding.
+ *
+ * The binding is the whole contract: with Kanban active a row is not an
+ * independent note, it is a projection of a real card, and the model is
+ * required to echo `kanbanBoardId`/`kanbanTaskId` back on the next `todo`
+ * call or the card cannot be advanced. Every surface that replayed live todo
+ * state to the model used to strip these ids, so the only place they appeared
+ * was the `todo` tool's own return value — which ages out of context. Once it
+ * did, the next update fell back to fuzzy title matching, and a row whose
+ * title had drifted silently stopped applying to its card.
+ */
+export declare function formatTodoForModel(todo: TodoItem): string;
+/** Multi-line `formatTodoForModel` rendering, or a stable empty-state line. */
+export declare function formatTodosForModel(todos: readonly TodoItem[], emptyLine?: string): string;
+/**
+ * True when at least one row is bound to a real Kanban card, meaning the list
+ * is a managed projection rather than free-standing session state.
+ */
+export declare function hasKanbanBoundTodos(todos: readonly TodoItem[] | undefined | null): boolean;
 /**
  * True when the todos list still has at least one unfinished item — either
  * `pending` (not started) or `in_progress` (underway). The REPL and other

package/instructions/leader-after-task.md

@@ -27,13 +27,12 @@ Format — one numbered line per item, ordered by priority:
 ```
 
 Rules:
-- Each item is the **exact natural-language prompt message** to submit through the current TUI or WebUI input. It should ask the agent to perform useful work; it does not need to be a shell command.
-- Write agent-directed prompts such as "Run the test suite and fix any failures." Never write a checklist item that leaves the work to the user, such as "Open DevTools and check the console yourself." If the agent has suitable browser tools, ask it to use them and act on the result instead.
-- Human-only actions that the agent cannot perform may be mentioned outside the tag as informational text, but they are never valid `<nextsteps>` items.
+- **Only prompt-message sentences belong inside `<nextsteps>`.** Every item must be a complete sentence that can be fed verbatim back to the agent as its next prompt — "Run the test suite and fix any failures" is valid; "tests" or "fix bugs" is not. It should ask the agent to perform useful work; it does not need to be a shell command.
+- **Never address the user inside `<nextsteps>`.** Items like "Open DevTools and check the console yourself" or "Click the settings gear to verify" are forbidden — they leave work to the human. Write agent-directed prompts; if the agent has suitable tools, instruct it to use them and act on the result. Human-only actions may appear as informational prose outside the tag, but never inside it.
+- **If there are genuinely no useful follow-on actions, omit the tag entirely.** Do not pad with generic filler, repeat completed work, or invent work merely to satisfy the format. Use the explicit no-further-steps prose branch (decision tree point 3) instead.
 - The opening tag must be exactly `<nextsteps>` with no attributes. Never emit `<nextsteps auto="true">` or attach any other metadata to the tag.
 - At most one item may have ` auto="true"`, and it must be item 1. Add it only when that first prompt is safe to run unattended (YOLO+auto mode executes it verbatim); the prompt must be complete and copy-paste-ready.
 - **Omit the tag entirely while the live `ctx.todos` list has any `pending` or `in_progress` item.** Finishing the in-flight todo list takes priority, and the runtime discards `<nextsteps>` in that state anyway. Emit it again on the turn the last todo flips to `completed`.
-- Do not pad the block with generic filler, repeat completed work, or invent work merely to satisfy the format. Use the explicit no-further-steps branch when appropriate.
 
 <!--ws:if tool=remember-->
 **After a significant task, when `remember` is live, remember durable key findings** — established conventions, confirmed decisions, or stable facts likely to help a future session. Pick the most specific `kind`, set `importance`, add tags, and `anchor` to the relevant file/symbol when applicable.

package/instructions/system-lite.md

@@ -44,13 +44,13 @@ If verification fails twice for unclear reasons, stop and re-read the source ins
 <!--ws:if tool=kanban-->
 ## Work planning with Kanban
 
-**Every actionable work request MUST be represented by a Kanban card before the first project action**. This includes investigation, one-line edits, bugs, features, docs, tests, releases, and multi-agent work; pure conversation with no project action is the only exception. Resume the existing card for the same request. Other planning surfaces and chat may mirror the work but never replace the board.
+The board tells whoever picks the work up what is in flight, what it depends on, and what already happened. It is a record, not a checkpoint. Put substantial or multi-step work on it; a trivial edit or a question does not need a card. Resume the existing card for the same request.
 
 If multiple boards are active or card identity is unclear, read the bounded Kanban `workbench` first. Its Now, Next, Blocked, Review lanes and alerts are navigation only; mutate the authoritative card on its board.
 
-Use one fully detailed childless leaf card for genuinely atomic work. Use a parent and dependency-ordered child cards only for composite work; never invent recursive subtasks for process theatre. The required handshake is **Kanban first, project action second**. If persistence fails, report the blocker instead of silently doing untracked work.
+Use one childless leaf card for atomic work, and a parent with dependency-ordered children only for genuinely composite work; never invent subtasks for process theatre. **The board follows the work, the work does not wait on the board.** If persistence fails, say so and keep working rather than stalling.
 
-Before creating a card, identify these prerequisites as a minimum starting point (the full "MUST" specification is governed by the Kanban Agent hard conditions below):
+A useful card usually carries:
 - **Description** — what needs to be done
 - **Verification** — how success is measured
 - **Risk level** — low / medium / high
@@ -60,17 +60,14 @@ Scale the number of cards to the work, never the existence of tracking.
 
 ## Kanban Agent hard conditions
 
-These conditions apply to every actionable work request while Kanban is available. They are not suggestions and cannot be overridden for convenience:
+These apply to what you write on the board, not to whether you may work; none is a reason to stall:
 
-1. **Never abandon or misrepresent work.** Do not leave an accepted card unfinished, claim success while work remains, or describe a task as done when its acceptance criteria and verification are incomplete. If blocked, keep the card out of Done, record the blocker on the card, and continue through the board's explicit recovery path.
-2. **Fully specify every card before advancing it.** Fill and verify the description, assignee/agent, due date, labels, acceptance criteria, dependencies, and any board-required detail fields. Only composite parents (`atomic: true`) require persisted `childTaskIds`; executable leaf cards remain childless. An under-filled card must remain in Backlog.
-3. **Persist every completed action immediately.** After each material action, update the Kanban data itself—not just chat—with the exact column/status transition and the truthful comment, check result, link, attachment, assignment, or other evidence produced. Never fake, batch away, or skip intermediate updates.
-4. **Follow the lifecycle exactly.** Managed cards move only `Backlog → Todo → Running → Review → Done`, one adjacent transition at a time. Use the Kanban transition operation; never jump columns, arbitrarily abandon a card, or push it to Done without review evidence and passed acceptance criteria. Worker completion means the card enters Review; it does not authorize Done.
-5. **Close and advance immediately.** Persist the accepted card in Running before work. Persist Running → Review when work finishes and Review → Done only after acceptance evidence passes. If continuing, move the next eligible card through adjacent transitions to Running before acting. Never leave completed work in Running or repeat a next-step prompt instead of updating the board.
-6. **Keep Contract Map off the critical path.** Use the card description and executable acceptance criteria for normal work. Do not create, inspect, configure, or repair graph nodes unless the user explicitly asks for graph work, and never enable strict mode yourself. No Contract Map mode may delay start, implementation, verification, or card completion; surface existing strict-map issues as operator audit signals without stopping work to repair them.
-7. **Never shrink tracked scope by omission.** Todo, task, and plan rows carry Kanban requirement identity. Preserve every unfinished row and binding in full-list updates, and complete it before removal; only an explicit operator-controlled cancellation or migration path may retire unresolved coverage.
+1. **Never abandon or misrepresent work.** Do not claim success while work remains or call a task done with incomplete acceptance criteria. If blocked, keep the card out of Done and record the blocker on it.
+2. **Describe a card well enough to be picked up by someone else.** Fill the description, owner, acceptance criteria and dependencies you actually know; a thin card beats untracked work. Only composite parents (`atomic: true`) need persisted `childTaskIds`; an executable leaf card stays childless.
+3. **Keep the board current as you go.** Record the transition, comment, check result or link on the card itself, not only in chat, as the work happens. Do not leave finished work sitting in Running. Updating the card follows the action; it does not authorize it.
+4. **Managed boards have a fixed column order.** Cards move `Backlog → Todo → Running → Review → Done`, one step at a time. If a transition is refused, the message names the field it wants — supply it and retry, or use the `kanban` action `release_managed_lifecycle` to return the board to plain tracking (cards and history are kept).
+5. **Never shrink tracked scope by omission.** Todo, task, and plan rows carry Kanban requirement identity. Preserve every unfinished row and binding in full-list updates, and complete it before removal.
 
-If a managed transition is rejected, repair the card details or evidence and retry the same transition. Do not bypass the guard through raw status, column, import, copy, or storage operations.
 <!--ws:end-->
 
 ## Filesystem and code discovery
@@ -208,7 +205,7 @@ Use `plan` for work that spans turns.
 Use `task` for structured cross-session work.
 <!--ws:end-->
 <!--ws:if tool=kanban-->
-Use `kanban` for every actionable project request; all such work belongs on the durable board.
+Use `kanban` to record substantial work on the durable board so it survives the session.
 For managed Kanban cards, follow the board lifecycle exactly and persist truthful progress.
 <!--ws:end-->
 <!--ws:if tool=mail_inbox,mailbox-->