@wrongstack/tools 0.303.0 → 0.305.1

package/dist/read.js

@@ -2867,6 +2867,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 fs from "node:fs/promises";
 import * as path2 from "node:path";
@@ -3898,86 +3978,6 @@ 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/writer.ts
 import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
 import * as fs8 from "node:fs";
@@ -5495,7 +5495,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);
@@ -5988,9 +5988,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(
@@ -6600,6 +6604,9 @@ 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((resolve4) => setImmediate(resolve4));
 }
@@ -6776,11 +6783,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) {
@@ -6805,6 +6808,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;
@@ -6846,12 +6853,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);
@@ -6944,7 +6953,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();
@@ -6994,12 +7003,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: stat3, lang, parsed } = result;
@@ -7007,6 +7018,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({
@@ -7031,6 +7043,7 @@ async function runIndexerWithStore(store, opts) {
             contentHash: result.contentHash ?? ""
           });
           filesIndexed++;
+          filesEmpty++;
         }
         continue;
       }
@@ -7044,6 +7057,7 @@ async function runIndexerWithStore(store, opts) {
           contentHash: result.contentHash ?? ""
         });
         filesIndexed++;
+        filesEmpty++;
         continue;
       }
       batchEntries.push({
@@ -7065,6 +7079,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);
@@ -7077,6 +7092,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);
@@ -7094,6 +7110,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)}`
             );
@@ -7126,6 +7143,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,
@@ -7254,7 +7277,6 @@ import * as fs10 from "node:fs";
 import * as os3 from "node:os";
 import * as path14 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { assertUnixSocketPathWithinLimit } from "@wrongstack/core/utils";
 var PROJECT_INDEX_SERVER_PROTOCOL_VERSION = 1;
 var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
 var PROJECT_INDEX_SERVER_SOCKET_DIR = `wsci-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}`;

package/dist/session-kanban.d.ts

@@ -3,7 +3,16 @@ import { type PlanFile, type PlanItem, type TaskFile } from '@wrongstack/core/st
 import type { SerializedTaskGraph } from '@wrongstack/core/types';
 import { type TaskItem } from '@wrongstack/core/utils';
 import { type KanbanBoard, type KanbanColumn, type KanbanTask } from '@wrongstack/kanban';
-/** The canonical workflow shared by WebUI and TUI session boards. */
+/**
+ * The canonical workflow shared by WebUI and TUI session boards.
+ *
+ * Session boards now use the same 5 standard columns as every other board
+ * (backlog, todo, in-progress, review, done). Formerly this shipped a 4-column
+ * variant without a backlog; the column lock unified the layout. Existing
+ * 4-column session_mirror boards are migrated automatically on the next session
+ * touch: `ensureSessionKanbanBoard`'s `sameColumns` check detects the drift
+ * and `updateBoard` reconciles to DEFAULT_COLUMNS.
+ */
 export declare const SESSION_KANBAN_COLUMNS: KanbanColumn[];
 /** Create (or migrate) the single Kanban board owned by a session. */
 export declare function ensureSessionKanbanBoard(projectRoot: string | undefined, sessionId: string): Promise<KanbanBoard | null>;
@@ -17,12 +26,35 @@ export declare function cleanupSessionKanbanBoard(projectRoot: string | undefine
 export declare function cleanupSessionKanbanBoardIfEmpty(projectRoot: string | undefined, sessionId: string): Promise<string[]>;
 /** Prune stale empty session boards while preserving manual and live boards. */
 export declare function cleanupEmptySessionKanbanBoards(projectRoot: string | undefined, activeSessionId?: string): Promise<string[]>;
+/**
+ * Consume the last unreported mirror failure for a session, if any.
+ *
+ * The mirror is asynchronous and fire-and-forget, so a rejected projection
+ * used to be observable only in stdout. The `todo` tool drains this on its
+ * next call and reports it as a warning, so a board that stopped tracking the
+ * session is surfaced where the divergence actually matters.
+ */
+export declare function takeSessionMirrorFailure(projectRoot: string | undefined, sessionId: string): string | undefined;
 export declare function todoListToSerializedGraph(todos: readonly TodoItem[], sessionId: string): SerializedTaskGraph;
 export declare function taskFileToSerializedGraph(tasks: readonly TaskItem[], sessionId: string): SerializedTaskGraph;
 export declare function planFileToSerializedGraph(items: readonly PlanItem[], sessionId: string): SerializedTaskGraph;
 export declare function projectSessionTodosToKanban(projectRoot: string | undefined, todos: readonly TodoItem[], sessionId: string): Promise<KanbanBoard | null>;
 export declare function projectSessionTasksToKanban(projectRoot: string | undefined, tasks: readonly TaskItem[], sessionId: string): Promise<KanbanBoard | null>;
 export declare function projectSessionPlanToKanban(projectRoot: string | undefined, items: readonly PlanItem[], sessionId: string): Promise<KanbanBoard | null>;
+/**
+ * The todo rows that still need the session mirror: those not already cards on
+ * the board this session is working on.
+ *
+ * The rule used to be all-or-nothing — the mirror was skipped only when EVERY
+ * row was bound. A single unbound row (a todo the model added to the chat list
+ * without also filing a card) sent the whole list to a separate session board,
+ * so work already tracked on the real board showed up a second time there, and
+ * one stray row was enough to leave a session board holding a single card.
+ *
+ * With no active board every row still needs mirroring, since there is no other
+ * place the work is being recorded.
+ */
+export declare function todosNeedingSessionMirror(todos: readonly TodoItem[], activeBoardId: string | undefined): readonly TodoItem[];
 export declare function mirrorSessionTodosToKanban(projectRoot: string | undefined, todos: readonly TodoItem[], sessionId: string): void;
 export declare function mirrorSessionTasksToKanban(projectRoot: string | undefined, tasks: readonly TaskItem[], sessionId: string): void;
 export declare function mirrorSessionPlanToKanban(projectRoot: string | undefined, items: readonly PlanItem[], sessionId: string): void;
@@ -33,6 +65,63 @@ export declare function mirrorSessionPlanToKanban(projectRoot: string | undefine
  */
 export declare function attachSessionKanbanMirror(context: Context): () => void;
 /** Fully hydrate a session board before a host announces the session as ready. */
+/**
+ * Re-bind the card this session was working, after a restart or `--resume`.
+ *
+ * The binding produced by `start_task` lives in `ctx.meta.kanban`, which is
+ * conversation state — nothing restores it. So a resumed session came back
+ * with `currentKanbanTaskId` undefined while its card still sat in Running on
+ * the board: file events lost their task attribution, and under
+ * `tools.kanbanGovernance` the run was un-bound until the model happened to
+ * call `start_task` again.
+ *
+ * Board presence is the durable anchor. It is keyed `<sessionId>:<agentId>`,
+ * carries the `taskId`, and is stored on the board record itself, so it
+ * survives the restart even though its derived `active` flag does not (the TTL
+ * is two minutes). Matching it against the cards that are actually still
+ * running gives an unambiguous answer without guessing from free-text agent
+ * ids.
+ *
+ * Deliberately conservative — it prefers to do nothing over binding the wrong
+ * card:
+ * - never overrides a binding this process already has;
+ * - only considers cards whose assignment is still `running`;
+ * - skips an expired lease, because `recover_stale` may have reassigned that
+ *   card to another worker;
+ * - picks the most recently seen entry when a session touched several.
+ *
+ * Session mirrors and archived boards are excluded by the snapshot's default
+ * board-kind filter, which is correct: `start_task` never targets them.
+ */
+export declare function rebindSessionKanbanTask(context: Context): Promise<{
+    boardId: string;
+    taskId: string;
+} | null>;
+/**
+ * Why session Kanban is unavailable, or undefined while it is healthy.
+ *
+ * Surfaces exist so a startup path can tell the user their board will not sync
+ * without having to catch and classify the failure itself. Cleared on the
+ * first hydrate that succeeds, so a daemon that comes back stops being
+ * reported as down.
+ */
+export declare function sessionKanbanDegradation(): string | undefined;
+/**
+ * Project the session's todos, plan, and tasks onto its Kanban board.
+ *
+ * Kanban is a projection: every card here is derived from state that lives
+ * somewhere else and is authoritative there. Losing the board costs the user a
+ * view, not any work — so an unreachable Kanban daemon degrades this to `null`
+ * rather than propagating.
+ *
+ * That distinction used to be missing, and it cost an entire session. When a
+ * killed daemon left a stale IPC endpoint behind, the connect error thrown
+ * here unwound through `setupSession` and killed `wstack` at startup: no
+ * prompt, no session, just a socket path in a stack trace — for a board the
+ * user had not asked to see. `bindProjectEndpoint` now stops the daemon from
+ * wedging in the first place, but the call site must still hold: an optional
+ * view may never take down the session it decorates.
+ */
 export declare function hydrateSessionKanban(context: Context): Promise<KanbanBoard | null>;
 export interface SessionKanbanSourceUpdate {
     source: 'todo' | 'task' | 'plan' | null;
@@ -40,6 +129,27 @@ export interface SessionKanbanSourceUpdate {
     tasks?: TaskFile | undefined;
     plan?: PlanFile | undefined;
 }
+/**
+ * Human-readable titles of the unfinished dependencies blocking a card.
+ *
+ * The board recomputes readiness on every mutation; this only carries the
+ * result to the todo surface. Titles rather than ids, because the row is read
+ * by a model and a human, neither of whom can resolve a raw card id.
+ */
+export declare function blockingTitles(board: KanbanBoard, task: KanbanTask): string[];
+/**
+ * Order cards the way they must actually be worked: dependencies first, then
+ * priority, then the board's own column/manual order.
+ *
+ * The managed projection previously sorted by `createdAt` — the moment a card
+ * happened to be created — which is unrelated to execution order, so the list
+ * the model reads top-to-bottom was not a plan. A dependency-respecting
+ * (Kahn) order makes the visible sequence the executable sequence; ties fall
+ * back to the deterministic board order so the list never reshuffles on its
+ * own. Any card left over by a dependency cycle is appended rather than
+ * dropped — the board rejects cycles, but a projection must never lose work.
+ */
+export declare function orderTasksForTodos(board: KanbanBoard, tasks: readonly KanbanTask[]): KanbanTask[];
 /**
  * Replace the tactical todo list from the current cards on a session-owned board.
  *