@wrongstack/tools 0.297.0 → 0.298.0

package/dist/patch.js

@@ -45,6 +45,10 @@ var patchTool = {
     useInstead: ["edit"]
   },
   permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The target directory. The patch body itself is unstable (every diff
+  // differs), so it could never re-match its own stored rule.
+  subjectKey: "directory",
   mutating: true,
   capabilities: ["fs.write"],
   icon: "edit",
@@ -168,7 +172,13 @@ function runPatch(args, cwd, signal) {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv(), LANG: "C", LC_ALL: "C" };
-    const child = spawn("patch", args, { cwd, signal, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    const child = spawn("patch", args, {
+      cwd,
+      signal,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
     child.stdout?.on("data", (c) => {
       stdout += c.toString();
     });

package/dist/plan.js

@@ -1,4 +1,5 @@
 // src/plan.ts
+import { randomUUID } from "node:crypto";
 import {
   addPlanItem,
   clearPlan,
@@ -6,14 +7,11 @@ import {
   formatPlan,
   getPlanTemplate,
   mutatePlan as mutatePlan2,
+  mutateTasks as mutateTasks2,
   removePlanItem,
   setPlanItemStatus
 } from "@wrongstack/core/storage";
-import {
-  mutateTasks as mutateTasks2
-} from "@wrongstack/core/storage";
 import { formatTaskList } from "@wrongstack/core/utils";
-import { randomUUID } from "node:crypto";
 
 // src/session-kanban.ts
 import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
@@ -77,7 +75,9 @@ async function ensureSessionKanbanBoard(projectRoot, sessionId) {
         description: "Live session work: todos, tasks, and plan items.",
         tags: sessionBoardTags(sessionId),
         columns: SESSION_KANBAN_COLUMNS,
-        generatedBy: `session-kanban:${sessionId}`
+        generatedBy: `session-kanban:${sessionId}`,
+        kind: "session_mirror",
+        retention: { mode: "archive_after_ttl", ttlMs: 7 * 24 * 60 * 60 * 1e3 }
       });
     }
     if (!sameColumns(board.columns) || !board.tags?.includes(SESSION_BOARD_TAG)) {
@@ -173,6 +173,9 @@ var planTool = {
   description: 'Manage a session-persistent strategic plan. The plan is written to disk and survives conversation resumptions within the same session, but is isolated to this session \u2014 other sessions have their own separate plans. Unlike todos (which are per-turn and lost on restart), a plan tracks high-level progress across multiple turns. Use this to outline big-picture work, then promote concrete items into the todo list when ready to execute. By default plans are isolated to this session; use `scope: "project"` to store the plan in a shared project-level file visible to all sessions.',
   usageHint: 'RECOMMENDED FOR COMPLEX, MULTI-PHASE WORK:\n\n- Start by creating a high-level plan with `action: "add"` or using templates (`template_use`).\n- Use `promote` to turn a plan item into actionable todos.\n- Use `taskify` to convert a plan item into a structured task (with type/priority/deps).\n- Keep plans at the "why and what" level, and todos at the "how and next step" level.\n- Common templates: "new-feature", "bug-fix", "refactor", "release", "security-audit".\n\nThis tool is excellent for maintaining long-term direction across many turns within a session. Plans survive resume but are not shared across separate sessions.\nUse `scope: "project"` to use a shared project-level plan file.',
   permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The action performed; plan has no single file or path subject.
+  subjectKey: "action",
   mutating: true,
   capabilities: ["fs.write"],
   icon: "plan",
@@ -229,7 +232,10 @@ var planTool = {
     let planPath;
     if (input.scope === "project") {
       if (typeof sessionPlanPath === "string") {
-        const lastSep = Math.max(sessionPlanPath.lastIndexOf("/"), sessionPlanPath.lastIndexOf("\\"));
+        const lastSep = Math.max(
+          sessionPlanPath.lastIndexOf("/"),
+          sessionPlanPath.lastIndexOf("\\")
+        );
         planPath = lastSep >= 0 ? sessionPlanPath.slice(0, lastSep + 1) + "backlog.plan.json" : "backlog.plan.json";
       }
     } else {
@@ -266,7 +272,11 @@ var planTool = {
           case "start":
           case "done": {
             if (!input.target) {
-              early = mkResult(p, false, `${input.action} requires \`target\` (id|index|substring).`);
+              early = mkResult(
+                p,
+                false,
+                `${input.action} requires \`target\` (id|index|substring).`
+              );
               return p;
             }
             const next = setPlanItemStatus(
@@ -294,7 +304,11 @@ var planTool = {
           }
           case "promote": {
             if (!input.target) {
-              early = mkResult(p, false, `${input.action} requires \`target\` (id|index|substring).`);
+              early = mkResult(
+                p,
+                false,
+                `${input.action} requires \`target\` (id|index|substring).`
+              );
               return p;
             }
             const derived = deriveTodosFromPlanItem(p, input.target, input.subtasks);
@@ -337,7 +351,11 @@ var planTool = {
             return clearPlan(p);
           case "taskify": {
             if (!input.target) {
-              early = mkResult(p, false, "taskify requires `target` (plan item id|index|substring).");
+              early = mkResult(
+                p,
+                false,
+                "taskify requires `target` (plan item id|index|substring)."
+              );
               return p;
             }
             let itemIdx = -1;
@@ -410,7 +428,11 @@ var planTool = {
 ${formatTaskList(taskFile.tasks)}`
         );
       } catch (err) {
-        return mkResult(plan, false, `taskify: task not saved \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        return mkResult(
+          plan,
+          false,
+          `taskify: task not saved \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     }
     return mkResult(plan, true, `Plan ${input.action} ok.`);

package/dist/read.js

@@ -1610,9 +1610,9 @@ function parseSymbols6(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename5 = path8.basename(file).toLowerCase();
-  const isPackageJson = basename5 === "package.json";
-  const isTsconfig = basename5 === "tsconfig.json" || basename5 === "tsconfig.build.json";
+  const basename6 = path8.basename(file).toLowerCase();
+  const isPackageJson = basename6 === "package.json";
+  const isTsconfig = basename6 === "tsconfig.json" || basename6 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -2001,12 +2001,13 @@ function ensureInsideRoot(absPath, ctx) {
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
 }
-async function assertRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return;
+async function resolveRealInsideRoot(absPath, ctx) {
+  if (ctx.allowOutsideProjectRoot) return absPath;
   const realRoots = await Promise.all(
     allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
   );
   let probe2 = absPath;
+  const pendingTail = [];
   for (; ; ) {
     let real;
     try {
@@ -2014,13 +2015,16 @@ async function assertRealInsideRoot(absPath, ctx) {
     } catch (err) {
       if (err.code === "ENOENT") {
         const parent = path.dirname(probe2);
-        if (parent === probe2) return;
+        if (parent === probe2) return absPath;
+        pendingTail.unshift(path.basename(probe2));
         probe2 = parent;
         continue;
       }
       throw err;
     }
-    if (isInsideAny(real, realRoots)) return;
+    if (isInsideAny(real, realRoots)) {
+      return pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
+    }
     throw new Error(
       `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
     );
@@ -2028,8 +2032,7 @@ async function assertRealInsideRoot(absPath, ctx) {
 }
 async function safeResolveReal(input, ctx) {
   const abs = safeResolve(input, ctx);
-  await assertRealInsideRoot(abs, ctx);
-  return abs;
+  return await resolveRealInsideRoot(abs, ctx);
 }
 function isBinaryBuffer(buf) {
   const len = Math.min(buf.length, 8192);
@@ -3006,6 +3009,7 @@ var REFS_INDEX_SQL = [
 var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
 
 // src/codebase-index/writer-search-helpers.ts
+var SEARCH_CANDIDATE_SCAN_CAP = 5e3;
 function normalizeSearchLimit(limit) {
   return typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : void 0;
 }
@@ -3035,8 +3039,8 @@ function buildWriterSearchWhere(query, filter) {
   }
   if (query.trim()) {
     const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
-    conditions.push(`(${tokens.map(() => "text LIKE ?").join(" OR ")})`);
-    for (const token of tokens) values.push(`%${token}%`);
+    conditions.push(`(${tokens.map(() => "text LIKE ? ESCAPE '\\'").join(" OR ")})`);
+    for (const token of tokens) values.push(`%${escapeLike(token)}%`);
   }
   return { where: conditions.length ? `WHERE ${conditions.join(" AND ")}` : "", values };
 }
@@ -3145,6 +3149,7 @@ var StorePool = class {
 
 // src/codebase-index/writer.ts
 var DB_FILE2 = "index.db";
+var MAX_STATEMENT_CACHE = 128;
 var IndexStore = class _IndexStore {
   db;
   /** Absolute path to this project's index directory. */
@@ -3182,12 +3187,31 @@ var IndexStore = class _IndexStore {
   // Dirty on open so the first getOrBuildBm25() rebuilds against current rows;
   // an empty or pre-existing corpus makes a stale IDF table meaningless.
   bm25Dirty = true;
-  /** Prepare-once helper: compile `sql` on first use, reuse thereafter. */
+  /**
+   * Prepare-once helper: compile `sql` on first use, reuse thereafter.
+   *
+   * Bounded LRU rather than an open Map. The cache is keyed by SQL TEXT, and
+   * the fallback search builder emits one `text LIKE ?` clause per query token
+   * — so the SQL varies with the token count and a stream of differently-sized
+   * queries grew the cache without limit. Sage's store already bounds its
+   * equivalent at 128 (WS-096).
+   *
+   * Re-inserting on a hit keeps the hot fixed-SQL statements (upsertFile,
+   * insertRefs, …) at the young end, so a burst of one-off search SQL evicts
+   * itself rather than the reindex hot path.
+   */
   stmt(sql) {
-    let s = this.stmtCache.get(sql);
-    if (s === void 0) {
-      s = this.db.prepare(sql);
-      this.stmtCache.set(sql, s);
+    const cached = this.stmtCache.get(sql);
+    if (cached !== void 0) {
+      this.stmtCache.delete(sql);
+      this.stmtCache.set(sql, cached);
+      return cached;
+    }
+    const s = this.db.prepare(sql);
+    this.stmtCache.set(sql, s);
+    if (this.stmtCache.size > MAX_STATEMENT_CACHE) {
+      const oldest = this.stmtCache.keys().next();
+      if (!oldest.done) this.stmtCache.delete(oldest.value);
     }
     return s;
   }
@@ -3460,7 +3484,7 @@ var IndexStore = class _IndexStore {
     const { where, values } = built;
     const limit = normalizeSearchLimit(opts?.limit);
     const limitSql = limit !== void 0 ? " LIMIT ?" : "";
-    const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}${limitSql}`;
+    const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment FROM symbols ${where}${limitSql}`;
     const binds = limit !== void 0 ? [...values, limit] : values;
     const rows = this.stmt(sql).all(
       ...binds
@@ -3589,11 +3613,13 @@ var IndexStore = class _IndexStore {
   /** Legacy ranked path: LIKE candidates + in-process BM25 + JS snippets. */
   searchRankedFallback(query, filter, limit) {
     if (!query.trim()) {
-      const total = this.countSearch(query, filter);
-      if (total === 0) return { results: [], total: 0 };
-      return { results: this.search(query, filter, { limit }), total };
+      const total2 = this.countSearch(query, filter);
+      if (total2 === 0) return { results: [], total: 0 };
+      return { results: this.search(query, filter, { limit }), total: total2 };
     }
-    const candidates = this.search(query, filter);
+    const total = this.countSearch(query, filter);
+    if (total === 0) return { results: [], total: 0 };
+    const candidates = this.search(query, filter, { limit: SEARCH_CANDIDATE_SCAN_CAP });
     if (candidates.length === 0) return { results: [], total: 0 };
     const candidateById = new Map(candidates.map((c) => [c.id, c]));
     const bm25 = this.getOrBuildBm25();
@@ -3619,7 +3645,7 @@ var IndexStore = class _IndexStore {
       const c = expectDefined4(candidateById.get(id));
       return { ...c, score, snippet: bm25.extractSnippet(id, qTokens) };
     });
-    return { results, total: candidates.length };
+    return { results, total };
   }
   getAllIndexable() {
     return getAllIndexableWithStatement((sql) => this.stmt(sql));
@@ -4726,6 +4752,8 @@ var ProjectServerConnection = class {
   connectResolve = null;
   connectReject = null;
   nextId = 1;
+  /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+  authToken;
   pending = /* @__PURE__ */ new Map();
   transition(status, options = {}) {
     const previous = connectionStates.get(this.endpoint);
@@ -4862,6 +4890,31 @@ var ProjectServerConnection = class {
     this.transition("offline");
     maybeStopHeartbeatLoop();
   }
+  /**
+   * WS-027: the per-process token, read from the daemon's owner-only metadata
+   * file — never from the `hello` frame, which the daemon sends to every
+   * socket that connects (the mistake WS-028 found in the SAGE daemon).
+   *
+   * Read lazily and re-read while unknown: the daemon starts listening before
+   * it writes metadata (endpoint ownership has to be won first), and a
+   * respawned daemon mints a new token, so a cached wrong one would be sticky.
+   */
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const raw = fs10.readFileSync(
+          projectIndexServerMetadataPath(this.projectRoot, this.indexDir),
+          "utf8"
+        );
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
+          this.authToken = parsed.authToken;
+        }
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
   request(message, options) {
     const socket = this.socket;
     if (!socket || socket.destroyed) {
@@ -4905,7 +4958,7 @@ var ProjectServerConnection = class {
           return;
         }
       }
-      this.write({ ...message, id });
+      this.write({ ...message, id, authToken: this.currentAuthToken() });
     });
   }
   async ensureConnected(spawnIfMissing) {
@@ -4952,6 +5005,7 @@ var ProjectServerConnection = class {
   connectOnce() {
     this.socket?.destroy();
     this.socket = null;
+    this.authToken = void 0;
     this.info = null;
     this.activity = null;
     this.health = null;

package/dist/replace.js

@@ -1,18 +1,18 @@
 // src/replace.ts
-import { expectDefined } from "@wrongstack/core/utils";
 import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path2 from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 import {
   atomicWrite,
   buildChildEnv,
   compileGlob,
   detectNewlineStyle,
+  expectDefined,
   normalizeToLf,
   toStyle,
   unifiedDiff
 } from "@wrongstack/core/utils";
-import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/_regex.ts
 var MAX_PATTERN_LEN = 256;
@@ -100,6 +100,10 @@ var replaceTool = {
   description: "Perform a search-and-replace across multiple files using a regex pattern. This is a powerful bulk transformation tool. Dry-run is ON by default \u2014 set `dry_run: false` to apply changes.",
   usageHint: "DANGEROUS IF USED CARELESSLY \u2014 review the diff output carefully.\n\nRecommended workflow:\n1. Run without `dry_run: false` first to see exactly what would change (dry-run is the default).\n2. Review the diff output, then re-run with `dry_run: false` to apply.\n3. Use a specific enough `pattern` (and `glob` / `files`) to avoid accidental broad changes.\n4. `replace_all` controls whether only the first match per file or all matches are replaced.\nThis tool is excellent for large-scale refactors (renaming, import updates, etc.) but must be used with caution.",
   permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The file scope being rewritten, not the pattern: a trust rule should say
+  // where a bulk replace may run.
+  subjectKey: "files",
   mutating: true,
   capabilities: ["fs.write"],
   icon: "edit",
@@ -259,7 +263,11 @@ async function globFiles(pattern, base, extraGlob) {
 function checkRg() {
   return new Promise((resolve2) => {
     try {
-      const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore", windowsHide: true });
+      const p = spawn("rg", ["--version"], {
+        env: buildChildEnv(),
+        stdio: "ignore",
+        windowsHide: true
+      });
       p.on("error", () => resolve2(false));
       p.on("close", (code) => resolve2(code === 0));
     } catch {

package/dist/scaffold.js

@@ -127,6 +127,7 @@ var scaffoldTool = {
   usageHint: "PREFERRED FOR SCAFFOLDING:\n\n- Use built-in templates when they match your needs (e.g. react-component, npm-package).\n- Supports `dry_run` so you can preview exactly what will be created.\n- Has the powerful `fs.write.outside-project` capability \u2014 review paths carefully.\nMuch cleaner and safer than manually writing multiple files.",
   permission: "confirm",
   mutating: true,
+  subjectKey: "name",
   capabilities: ["fs.write.outside-project", "fs.write"],
   icon: "scaffold",
   timeoutMs: 3e4,
@@ -201,15 +202,17 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
     output: dryRun ? `Would create ${filesCreated} files: ${files.join(", ")}` : `Created ${filesCreated} files: ${files.join(", ")}`
   };
 }
+function escapeRegexLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function substituteVars(content, name, vars) {
+  const kebab = name.toLowerCase().replace(/\s+/g, "-");
+  const pascal = name.replace(/(?:^|[-_\s]+)([a-z])/g, (_, c) => c.toUpperCase());
   let result = content;
-  result = result.replace(/\{\{name\}\}/g, name.toLowerCase().replace(/\s+/g, "-"));
-  result = result.replace(
-    /\{\{Name\}\}/g,
-    name.replace(/(?:^|[-_\s]+)([a-z])/g, (_, c) => c.toUpperCase())
-  );
+  result = result.replace(/\{\{name\}\}/g, () => kebab);
+  result = result.replace(/\{\{Name\}\}/g, () => pascal);
   for (const [k, v] of Object.entries(vars)) {
-    result = result.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v);
+    result = result.replace(new RegExp(`\\{\\{${escapeRegexLiteral(k)}\\}\\}`, "g"), () => v);
   }
   return result;
 }

package/dist/session-kanban.js

@@ -90,7 +90,9 @@ async function ensureSessionKanbanBoard(projectRoot, sessionId) {
         description: "Live session work: todos, tasks, and plan items.",
         tags: sessionBoardTags(sessionId),
         columns: SESSION_KANBAN_COLUMNS,
-        generatedBy: `session-kanban:${sessionId}`
+        generatedBy: `session-kanban:${sessionId}`,
+        kind: "session_mirror",
+        retention: { mode: "archive_after_ttl", ttlMs: 7 * 24 * 60 * 60 * 1e3 }
       });
     }
     if (!sameColumns(board.columns) || !board.tags?.includes(SESSION_BOARD_TAG)) {
@@ -325,12 +327,26 @@ function projectSessionPlanToKanban(projectRoot, items, sessionId) {
 function fireAndForget(context, work) {
   void work.catch((err) => {
     const message = err instanceof Error ? err.message : String(err);
-    console.warn(JSON.stringify({ level: "warn", event: "session-kanban", context, message, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "session-kanban",
+        context,
+        message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
   });
 }
 function broadcastTodoUpdate(context, todos) {
   const sessionId = context.session?.id ?? "";
   if (!context.agentId || !sessionId) return;
+  const statusCounts = { pending: 0, inProgress: 0, completed: 0 };
+  for (const todo of todos) {
+    if (todo.status === "completed") statusCounts.completed++;
+    else if (todo.status === "in_progress") statusCounts.inProgress++;
+    else statusCounts.pending++;
+  }
   const projectDir = resolveWstackPaths({ projectRoot: context.projectRoot }).projectDir;
   const mailbox = getSharedProjectMailbox(projectDir);
   void mailbox.send({
@@ -342,11 +358,11 @@ function broadcastTodoUpdate(context, todos) {
       kind: "kanban.todos.updated",
       sessionId,
       revision: context.state.revision,
-      todos
+      todoCount: todos.length,
+      statusCounts
     }),
     priority: "normal",
-    senderSessionId: sessionId,
-    ttlMs: 6 * 60 * 60 * 1e3
+    senderSessionId: sessionId
   }).catch(() => {
   });
 }

package/dist/task.js

@@ -78,7 +78,9 @@ async function ensureSessionKanbanBoard(projectRoot, sessionId) {
         description: "Live session work: todos, tasks, and plan items.",
         tags: sessionBoardTags(sessionId),
         columns: SESSION_KANBAN_COLUMNS,
-        generatedBy: `session-kanban:${sessionId}`
+        generatedBy: `session-kanban:${sessionId}`,
+        kind: "session_mirror",
+        retention: { mode: "archive_after_ttl", ttlMs: 7 * 24 * 60 * 60 * 1e3 }
       });
     }
     if (!sameColumns(board.columns) || !board.tags?.includes(SESSION_BOARD_TAG)) {