@wrongstack/core 0.302.2 → 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
@@ -5444,6 +5577,9 @@ function subjectForToolInput(toolName, input, subjectKey) {
   const obj = input;
   if (subjectKey) {
     const value = obj[subjectKey];
+    if (Array.isArray(value)) {
+      return escapeGlobSubject(JSON.stringify(value));
+    }
     if (typeof value === "string") {
       if (isPathSubjectKey(subjectKey)) {
         const normalized = normalizePathSubject(value);
@@ -5596,6 +5732,7 @@ export {
   TerminalLifecycle,
   WIRE_TOOL_NAME_MAX_LENGTH,
   WIRE_TOOL_NAME_PATTERN,
+  activateProjectStateGuard,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -5661,6 +5798,8 @@ export {
   formatCompletedWorkLedger,
   formatTaskList,
   formatTaskProgress,
+  formatTodoForModel,
+  formatTodosForModel,
   formatTodosList,
   getCalibrationState,
   getChildEnvGitIdentity,
@@ -5669,6 +5808,7 @@ export {
   getPerfProfile,
   getToolDescriptionMode,
   getToolResultRenderMode,
+  hasKanbanBoundTodos,
   hasMeaningfulContent,
   hasOpenTodos,
   indexParallelBatchSize,
@@ -5747,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.