threadnote 0.7.11 → 1.0.0

package/dist/mcp_server.cjs

@@ -3645,49 +3645,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        relative3 = parse3(serialize(relative3, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative3.scheme) {
+        target.scheme = relative3.scheme;
+        target.userinfo = relative3.userinfo;
+        target.host = relative3.host;
+        target.port = relative3.port;
+        target.path = removeDotSegments(relative3.path || "");
+        target.query = relative3.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
+          target.userinfo = relative3.userinfo;
+          target.host = relative3.host;
+          target.port = relative3.port;
+          target.path = removeDotSegments(relative3.path || "");
+          target.query = relative3.query;
         } else {
-          if (!relative2.path) {
+          if (!relative3.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative3.query !== void 0) {
+              target.query = relative3.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative3.path[0] === "/") {
+              target.path = removeDotSegments(relative3.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative3.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative3.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative3.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3695,7 +3695,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative3.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -30950,14 +30950,18 @@ var StdioServerTransport = class {
 };
 
 // src/mcp_server.ts
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 
 // src/constants.ts
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 
+// src/index_repair.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+
 // src/manifest.ts
 var import_promises2 = require("node:fs/promises");
 
@@ -33808,6 +33812,13 @@ async function sleep(ms) {
     setTimeout(resolvePromise, ms);
   });
 }
+async function ensureDirectory(path, dryRun) {
+  if (dryRun) {
+    console.log(`Would create directory: ${path}`);
+    return;
+  }
+  await (0, import_promises.mkdir)(path, { recursive: true });
+}
 async function exists(path) {
   try {
     await (0, import_promises.access)(path);
@@ -33893,6 +33904,9 @@ function uniqueUsefulWorkspaceTerms(values) {
   }
   return terms;
 }
+function toPosixPath(path) {
+  return path.split(import_node_path.sep).join("/");
+}
 function trimTrailingSlash(value) {
   return value.endsWith("/") ? value.slice(0, -1) : value;
 }
@@ -34043,8 +34057,236 @@ function readStringArray(object3, key) {
   return value;
 }
 
+// src/runtime.ts
+function withIdentity(config2, args) {
+  return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
+}
+
+// src/index_repair.ts
+var AUTO_REPAIR_STATE_FILE = "index-auto-repair.json";
+var AUTO_REPAIR_TTL_MS = 6 * 60 * 60 * 1e3;
+var MAX_SCAN_DEPTH = 5;
+var MAX_REPAIR_TARGETS = 4;
+async function repairStaleRecallIndex(config2, ov, options = {}) {
+  const targets = await findStaleRecallIndexTargets(config2, options);
+  if (targets.length === 0) {
+    return { repairedUris: [], skippedRecentUris: [], warnings: [] };
+  }
+  const state = options.dryRun === true ? { entries: {}, version: 1 } : await readAutoRepairState(config2);
+  const now = Date.now();
+  const repairedUris = [];
+  const skippedRecentUris = [];
+  const warnings = [];
+  for (const target of targets.slice(0, options.maxTargets ?? MAX_REPAIR_TARGETS)) {
+    const previous = state.entries[target.uri];
+    if (previous?.signature === target.signature && now - Date.parse(previous.repairedAt) < AUTO_REPAIR_TTL_MS && options.dryRun !== true && options.ignoreBackoff !== true) {
+      skippedRecentUris.push(target.uri);
+      continue;
+    }
+    if (options.dryRun === true) {
+      repairedUris.push(target.uri);
+      continue;
+    }
+    const result = await runCommand(
+      ov,
+      withIdentity(config2, ["reindex", target.uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
+      { allowFailure: true }
+    );
+    if (result.exitCode === 0) {
+      repairedUris.push(target.uri);
+      state.entries[target.uri] = { repairedAt: new Date(now).toISOString(), signature: target.signature };
+    } else {
+      warnings.push(indexRepairWarning(target.uri, result));
+    }
+  }
+  if (options.dryRun !== true && repairedUris.length > 0) {
+    await writeAutoRepairState(config2, state);
+  }
+  return { repairedUris, skippedRecentUris, warnings };
+}
+async function findStaleRecallIndexTargets(config2, options = {}) {
+  const roots = await scanRoots(config2, options);
+  const byUri = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    if (!await exists(root.path)) {
+      continue;
+    }
+    const sidecars = await staleSidecars(root.path, root.uri);
+    if (options.collapseToRoots === true) {
+      if (sidecars.length === 0) {
+        continue;
+      }
+      const parts = sidecars.map((sidecar) => `${sidecar.relativePath}
+${sidecar.content}`);
+      byUri.set(root.uri, {
+        parts,
+        staleCount: sidecars.length,
+        uri: root.uri
+      });
+      continue;
+    }
+    for (const sidecar of sidecars) {
+      const current = byUri.get(sidecar.uri) ?? { parts: [], staleCount: 0, uri: sidecar.uri };
+      current.parts.push(`${sidecar.relativePath}
+${sidecar.content}`);
+      current.staleCount += 1;
+      byUri.set(sidecar.uri, current);
+    }
+  }
+  return [...byUri.values()].map((target) => ({
+    signature: sha256([target.uri, ...target.parts.sort()].join("\n---\n")),
+    staleCount: target.staleCount,
+    uri: target.uri
+  }));
+}
+function formatRecallIndexRepairMessages(result, options = {}) {
+  const messages = [];
+  for (const uri of result.repairedUris) {
+    messages.push(
+      `${options.dryRun === true ? "Would auto-reindex stale recall scope" : "Auto-reindexed stale recall scope"}: ${uri}`
+    );
+  }
+  for (const warning2 of result.warnings) {
+    messages.push(`Auto-index repair warning: ${warning2}`);
+  }
+  return messages;
+}
+function filterStaleRecallSummaryRows(output) {
+  return output.split(/\r?\n/).filter((line) => !isStaleRecallSummaryRow(line)).join("\n").trim();
+}
+function isStaleRecallSummaryRow(line) {
+  return /viking:\/\/\S+\/\.(?:abstract|overview)\.md\b/.test(line) && isStaleSummary(line);
+}
+async function scanRoots(config2, options) {
+  const accountRoot = (0, import_node_path2.join)(config2.agentContextHome, "data", "viking", config2.account);
+  const roots = [
+    {
+      path: (0, import_node_path2.join)(accountRoot, "user", uriSegment(config2.user), "memories"),
+      uri: `viking://user/${uriSegment(config2.user)}/memories`
+    }
+  ];
+  const query = options.query;
+  if (query) {
+    const project = await inferProjectFromQuery(config2.manifestPath, query);
+    const projectPath = project?.uri.startsWith("viking://resources/") ? (0, import_node_path2.join)(accountRoot, "resources", ...project.uri.slice("viking://resources/".length).split("/")) : void 0;
+    if (project && projectPath) {
+      roots.push({ path: projectPath, uri: project.uri });
+    }
+  }
+  if (options.includeManifestResources === true) {
+    roots.push(...await manifestResourceRoots(config2, accountRoot));
+  }
+  const scanAgentSkills = options.includeAgentSkills === true || (query ? /\bskills?\b/.test(query.toLowerCase()) : false);
+  if (scanAgentSkills) {
+    roots.push({ path: (0, import_node_path2.join)(accountRoot, "resources", "agent-skills"), uri: "viking://resources/agent-skills" });
+  }
+  return dedupeRoots(roots);
+}
+async function manifestResourceRoots(config2, accountRoot) {
+  try {
+    const manifest = await readSeedManifest(config2.manifestPath);
+    return manifest.projects.filter((project) => project.uri.startsWith("viking://resources/")).map((project) => ({
+      path: (0, import_node_path2.join)(accountRoot, "resources", ...project.uri.slice("viking://resources/".length).split("/")),
+      uri: project.uri
+    }));
+  } catch (_err) {
+    return [];
+  }
+}
+function dedupeRoots(roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const root of roots) {
+    if (seen.has(root.uri)) {
+      continue;
+    }
+    seen.add(root.uri);
+    deduped.push(root);
+  }
+  return deduped;
+}
+async function staleSidecars(rootPath, rootUri) {
+  const results = [];
+  async function visit(path, depth) {
+    let entries;
+    try {
+      entries = await (0, import_promises3.readdir)(path, { withFileTypes: true });
+    } catch (_err) {
+      return;
+    }
+    for (const entry of entries) {
+      const childPath = (0, import_node_path2.join)(path, entry.name);
+      if (entry.isFile() && isSummarySidecar(entry.name)) {
+        let content;
+        try {
+          content = await (0, import_promises3.readFile)(childPath, "utf8");
+        } catch (_err) {
+          continue;
+        }
+        if (!isStaleSummary(content)) {
+          continue;
+        }
+        const parentPath = (0, import_node_path2.dirname)(childPath);
+        const parentRelative = toPosixPath((0, import_node_path2.relative)(rootPath, parentPath));
+        const relativePath = toPosixPath((0, import_node_path2.relative)(rootPath, childPath));
+        results.push({
+          content: content.trim(),
+          relativePath,
+          uri: parentRelative ? `${trimLocalRootUri(rootUri)}/${parentRelative}` : trimLocalRootUri(rootUri)
+        });
+      } else if (entry.isDirectory() && depth < MAX_SCAN_DEPTH) {
+        await visit(childPath, depth + 1);
+      }
+    }
+  }
+  await visit(rootPath, 0);
+  return results;
+}
+function isSummarySidecar(name) {
+  return name === ".abstract.md" || name === ".overview.md";
+}
+function isStaleSummary(content) {
+  return content.includes("[Directory overview is not ready]") || content.includes("[Directory abstract is not ready]");
+}
+function trimLocalRootUri(uri) {
+  return uri.endsWith("/") ? uri.slice(0, -1) : uri;
+}
+async function readAutoRepairState(config2) {
+  const raw = await readFileIfExists(autoRepairStatePath(config2));
+  if (!raw) {
+    return { entries: {}, version: 1 };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isJsonObject(parsed) || parsed.version !== 1 || !isJsonObject(parsed.entries)) {
+      return { entries: {}, version: 1 };
+    }
+    const entries = {};
+    for (const [uri, entry] of Object.entries(parsed.entries)) {
+      if (isJsonObject(entry) && typeof entry.signature === "string" && typeof entry.repairedAt === "string") {
+        entries[uri] = { repairedAt: entry.repairedAt, signature: entry.signature };
+      }
+    }
+    return { entries, version: 1 };
+  } catch (_err) {
+    return { entries: {}, version: 1 };
+  }
+}
+async function writeAutoRepairState(config2, state) {
+  const path = autoRepairStatePath(config2);
+  await ensureDirectory((0, import_node_path2.dirname)(path), false);
+  await (0, import_promises3.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+function autoRepairStatePath(config2) {
+  return (0, import_node_path2.join)(config2.agentContextHome, AUTO_REPAIR_STATE_FILE);
+}
+function indexRepairWarning(uri, result) {
+  return `${uri}: ${result.stderr.trim() || result.stdout.trim() || "reindex failed"}`;
+}
+
 // src/memory_hygiene.ts
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var HYGIENE_SOURCES_HEADING = "## Threadnote Hygiene Sources";
 var STALE_HANDOFF_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
 function parseMemoryDocument(uri, content) {
@@ -34327,7 +34569,7 @@ function branchFromBody(body) {
   return branch?.split(/\s+/)[0]?.replace(/[.,;:]+$/g, "");
 }
 function topicFromUri(uri) {
-  const name = (0, import_node_path2.basename)(uri).replace(/\.md$/, "");
+  const name = (0, import_node_path3.basename)(uri).replace(/\.md$/, "");
   return name.startsWith("threadnote-") ? void 0 : name;
 }
 function parseProjectFromUri(uri) {
@@ -34357,7 +34599,7 @@ function preferredKeepRecord(records, topic) {
 }
 function isStableRecord(record2, topic) {
   const recordTopic = topic ?? topicForRecord(record2);
-  return recordTopic !== void 0 && (0, import_node_path2.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
+  return recordTopic !== void 0 && (0, import_node_path3.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
 }
 function sortedNewestFirst(records) {
   return [...records].sort((left, right) => {
@@ -34469,16 +34711,9 @@ function formatPlanSection(title, lines) {
 }
 
 // src/share.ts
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
-
-// src/runtime.ts
-function withIdentity(config2, args) {
-  return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
-}
-
-// src/share.ts
+var import_node_path4 = require("node:path");
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
 var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
@@ -34585,7 +34820,7 @@ function autoShareState(config2) {
   return state;
 }
 function pendingReindexesPath(config2) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
 }
 async function loadPendingReindexes(config2, state) {
   const raw = await readFileIfExists(pendingReindexesPath(config2));
@@ -34622,18 +34857,18 @@ async function loadPendingReindexes(config2, state) {
 async function writePendingReindexes(config2, state) {
   const path = pendingReindexesPath(config2);
   if (state.pendingReindexes.size === 0) {
-    await (0, import_promises3.rm)(path, { force: true });
+    await (0, import_promises4.rm)(path, { force: true });
     return;
   }
   const contents = {
     teams: Object.fromEntries(state.pendingReindexes),
     version: 1
   };
-  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
-  await (0, import_promises3.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
+  await (0, import_promises4.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await (0, import_promises3.rename)(tempPath, path);
+  await (0, import_promises4.rename)(tempPath, path);
 }
 async function refreshShareUpdateState(config2, options) {
   const state = autoShareState(config2);
@@ -34729,7 +34964,7 @@ async function runShareSyncQuiet(config2, state, options) {
   const beforeRev = await gitOutput(worktree, ["rev-parse", "HEAD"], false);
   const pullResult = await runCommand(git, ["-C", worktree, "rebase", "@{u}"], { allowFailure: true });
   if (pullResult.exitCode !== 0) {
-    if (await exists((0, import_node_path3.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path3.join)(team.config.gitdir, "rebase-apply"))) {
+    if (await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-apply"))) {
       throw new Error(
         `Automatic share sync hit git conflicts in ${worktree}. Resolve them in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then rerun recall/read.`
       );
@@ -34814,10 +35049,10 @@ function normalizeTeamName(input) {
   return candidate;
 }
 function teamsFilePath(config2) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams.json");
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams.json");
 }
 function teamWorktreePath(config2, team) {
-  return (0, import_node_path3.join)(
+  return (0, import_node_path4.join)(
     config2.agentContextHome,
     "data",
     "viking",
@@ -34830,7 +35065,7 @@ function teamWorktreePath(config2, team) {
   );
 }
 function teamGitdirPath(config2, team) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
 async function readTeamsFile(config2) {
   const path = teamsFilePath(config2);
@@ -34886,7 +35121,7 @@ async function resolveTeam(config2, requested) {
   return { config: found, name: wantName };
 }
 function workfileToVikingUri(config2, team, filePath) {
-  const rel = (0, import_node_path3.relative)(team.worktree, filePath).split(import_node_path3.sep).join("/");
+  const rel = (0, import_node_path4.relative)(team.worktree, filePath).split(import_node_path4.sep).join("/");
   return `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config2, uri) {
@@ -35011,13 +35246,14 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, o
     }
     return;
   }
-  const stagingDir = await (0, import_promises3.mkdtemp)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path3.join)(stagingDir, "body.txt");
+  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path4.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path4.join)(stagingDir, "body.txt");
   try {
-    await (0, import_promises3.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await (0, import_promises4.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode, options);
+    await refreshMemoryIndex(config2, ov, uri, options);
   } finally {
-    await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
@@ -35072,6 +35308,27 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, opt
     }
   }
 }
+async function refreshMemoryIndex(config2, ov, uri, options = {}) {
+  const result = await runCommand(
+    ov,
+    withIdentity(config2, ["reindex", uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
+    { allowFailure: true }
+  );
+  if (result.exitCode === 0) {
+    if (options.quiet !== true && result.stdout.trim()) {
+      console.log(result.stdout.trim());
+    }
+    if (options.quiet !== true && result.stderr.trim()) {
+      console.error(result.stderr.trim());
+    }
+    return;
+  }
+  if (options.quiet !== true) {
+    console.error(
+      `Memory stored, but index refresh failed for ${uri}: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+  }
+}
 async function waitForOvQueue(ov, config2, options = {}) {
   const result = await runCommand(ov, withIdentity(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
   if (options.quiet !== true && result.stdout.trim()) {
@@ -35092,7 +35349,7 @@ ${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed");
 }
 async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
-  const content = await (0, import_promises3.readFile)(filePath, "utf8");
+  const content = await (0, import_promises4.readFile)(filePath, "utf8");
   await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
 }
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
@@ -35157,8 +35414,8 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
       const oldRel = entries[index + 1];
       const newRel = entries[index + 2];
       if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path3.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path3.join)(worktree, newRel), relativePath: newRel, status: "added" });
+        changes.push({ path: (0, import_node_path4.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path4.join)(worktree, newRel), relativePath: newRel, status: "added" });
       }
       index += 3;
       continue;
@@ -35166,7 +35423,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
     const rel = entries[index + 1];
     if (rel) {
       const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path3.join)(worktree, rel), relativePath: rel, status });
+      changes.push({ path: (0, import_node_path4.join)(worktree, rel), relativePath: rel, status });
     }
     index += 2;
   }
@@ -35516,6 +35773,14 @@ async function runRecallTool(config2, params) {
     cwd: params.callerCwd,
     includeProcessCwd: false
   });
+  let indexRepairMessages;
+  try {
+    const ov = await requiredOpenVikingCli2();
+    const indexRepair = await repairStaleRecallIndex(config2, ov, { query: projectQuery });
+    indexRepairMessages = formatRecallIndexRepairMessages(indexRepair);
+  } catch (err) {
+    indexRepairMessages = [`Auto-index repair warning: ${errorMessage(err)}`];
+  }
   const contextualParams = { ...params, query };
   const baseArgs = [
     "search",
@@ -35532,8 +35797,13 @@ async function runRecallTool(config2, params) {
     return semanticResult;
   }
   const sections = [];
-  if (firstContent.text) {
-    sections.push(firstContent.text);
+  const semanticText = filterStaleRecallSummaryRows(firstContent.text);
+  const filteredSemanticText = semanticText !== firstContent.text.trim();
+  if (semanticText) {
+    sections.push(semanticText);
+  }
+  if (indexRepairMessages.length > 0) {
+    sections.push(indexRepairMessages.join("\n"));
   }
   const seededSection = await seededResourcesSection(config2, contextualParams, projectQuery);
   if (seededSection) {
@@ -35554,7 +35824,7 @@ ${exactMatches}`);
   for (const warning2 of syncWarnings) {
     sections.push(`Auto-sync warning: ${warning2}`);
   }
-  if (sections.length <= 1) {
+  if (sections.length <= 1 && !filteredSemanticText) {
     return semanticResult;
   }
   return { ...semanticResult, content: [{ type: "text", text: sections.join("\n\n") }] };
@@ -35592,7 +35862,7 @@ async function seededResourcesSection(config2, params, projectQuery) {
   if (result.exitCode !== 0) {
     return void 0;
   }
-  const body = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+  const body = filterStaleRecallSummaryRows([result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n"));
   if (!body) {
     return void 0;
   }
@@ -35914,7 +36184,7 @@ async function scopedCompactRecords(config2, options) {
     const uriDirectory = memoryUriDirectoryForCompact(config2, kind, options.project);
     let entries;
     try {
-      entries = await (0, import_promises4.readdir)(directory, { withFileTypes: true });
+      entries = await (0, import_promises5.readdir)(directory, { withFileTypes: true });
     } catch (_err) {
       continue;
     }
@@ -35922,7 +36192,7 @@ async function scopedCompactRecords(config2, options) {
       if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
         continue;
       }
-      const content = await readTextIfExists((0, import_node_path4.join)(directory, entry.name));
+      const content = await readTextIfExists((0, import_node_path5.join)(directory, entry.name));
       if (!content) {
         continue;
       }
@@ -35957,11 +36227,11 @@ function localMemoryDirectoryForCompact(config2, kind, project) {
   const projectSegment = uriSegment2(project);
   switch (kind) {
     case "durable":
-      return (0, import_node_path4.join)(root, "durable", "projects", projectSegment);
+      return (0, import_node_path5.join)(root, "durable", "projects", projectSegment);
     case "handoff":
-      return (0, import_node_path4.join)(root, "handoffs", "active", projectSegment);
+      return (0, import_node_path5.join)(root, "handoffs", "active", projectSegment);
     case "incident":
-      return (0, import_node_path4.join)(root, "incidents", "active", projectSegment);
+      return (0, import_node_path5.join)(root, "incidents", "active", projectSegment);
   }
 }
 function memoryUriDirectoryForCompact(config2, kind, project) {
@@ -35981,18 +36251,18 @@ function localMemoryPathForUri(config2, uri) {
   if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
     return void 0;
   }
-  const relative2 = uri.slice(prefix.length);
-  if (relative2.includes("..") || relative2.startsWith("/")) {
+  const relative3 = uri.slice(prefix.length);
+  if (relative3.includes("..") || relative3.startsWith("/")) {
     return void 0;
   }
-  return (0, import_node_path4.join)(localUserMemoriesRoot(config2), ...relative2.split("/"));
+  return (0, import_node_path5.join)(localUserMemoriesRoot(config2), ...relative3.split("/"));
 }
 function localUserMemoriesRoot(config2) {
-  return (0, import_node_path4.join)(config2.agentContextHome, "data", "viking", config2.account, "user", uriSegment2(config2.user), "memories");
+  return (0, import_node_path5.join)(config2.agentContextHome, "data", "viking", config2.account, "user", uriSegment2(config2.user), "memories");
 }
 async function readTextIfExists(path) {
   try {
-    return await (0, import_promises4.readFile)(path, "utf8");
+    return await (0, import_promises5.readFile)(path, "utf8");
   } catch (_err) {
     return void 0;
   }
@@ -36285,8 +36555,8 @@ async function runSharePublishTool(config2, sourceUri, options) {
         `Refusing to publish: ${targetUri} already exists in the shared namespace. Inspect it via threadnote read; if it should be replaced, forget the existing shared copy first.`
       );
     }
-    await ensureSharedDirectoryChain(config2, ov, targetUri, false);
-    await writeMemoryFile(config2, ov, targetUri, content, "create", false);
+    await ensureSharedDirectoryChain(config2, ov, targetUri, false, { quiet: true });
+    await writeMemoryFile(config2, ov, targetUri, content, "create", false, { quiet: true });
     const messages = [`Published ${sourceUri} -> ${targetUri}`];
     for (const redaction of scrub.redactions) {
       messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
@@ -36327,7 +36597,7 @@ function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
   if (!command2) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }
@@ -36336,8 +36606,8 @@ async function requiredOpenVikingCli2() {
 async function firstExistingPath(paths) {
   for (const path of paths) {
     try {
-      await (0, import_promises4.access)(path);
-      return await (0, import_promises4.realpath)(path);
+      await (0, import_promises5.access)(path);
+      return await (0, import_promises5.realpath)(path);
     } catch (_err) {
       continue;
     }