threadnote 0.7.12 → 1.1.0

package/dist/threadnote.cjs

@@ -3472,7 +3472,7 @@ var {
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.3.21";
+var DEFAULT_OPENVIKING_VERSION = "0.3.24";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 var OPENVIKING_PACKAGE_NAME = "openviking[local-embed]";
@@ -3523,8 +3523,8 @@ var DEFAULT_SEED_PATTERNS = [
 ];
 
 // src/hooks.ts
-var import_promises7 = require("node:fs/promises");
-var import_node_path9 = require("node:path");
+var import_promises8 = require("node:fs/promises");
+var import_node_path10 = require("node:path");
 
 // src/mcp.ts
 var import_node_fs2 = require("node:fs");
@@ -3616,6 +3616,41 @@ async function withSpinner(message, action) {
     (0, import_node_readline.cursorTo)(import_node_process.stdout, 0);
   }
 }
+function startProgress(message) {
+  if (import_node_process.stdout.isTTY !== true || process.env.CI !== void 0 || process.env.THREADNOTE_NO_SPINNER !== void 0) {
+    console.log(message);
+    return {
+      update(nextMessage) {
+        console.log(nextMessage);
+      },
+      stop() {
+        return;
+      }
+    };
+  }
+  const frames = ["-", "\\", "|", "/"];
+  let frameIndex = 0;
+  let currentMessage = message;
+  const render = () => {
+    (0, import_node_readline.clearLine)(import_node_process.stdout, 0);
+    (0, import_node_readline.cursorTo)(import_node_process.stdout, 0);
+    import_node_process.stdout.write(`${muted(frames[frameIndex])} ${currentMessage}`);
+    frameIndex = (frameIndex + 1) % frames.length;
+  };
+  const timer = setInterval(render, 100);
+  render();
+  return {
+    update(nextMessage) {
+      currentMessage = nextMessage;
+      render();
+    },
+    stop() {
+      clearInterval(timer);
+      (0, import_node_readline.clearLine)(import_node_process.stdout, 0);
+      (0, import_node_readline.cursorTo)(import_node_process.stdout, 0);
+    }
+  };
+}
 
 // src/utils.ts
 function isJsonObject(value) {
@@ -3753,15 +3788,11 @@ async function maybeRun(dryRun, executable, args, options = {}) {
 }
 async function runCommand(executable, args, options = {}) {
   return new Promise((resolvePromise, rejectPromise) => {
-    const child = (0, import_node_child_process.spawn)(executable, args, { cwd: options.cwd });
-    const stdoutChunks = [];
-    const stderrChunks = [];
     const maxOutputBytes = options.maxOutputBytes ?? defaultCommandMaxOutputBytes();
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
     let finished = false;
-    let failureResult;
     let killTimer;
+    let killEscalationTimer;
+    let failureMessage;
     let sentTerminationSignal = false;
     const timeoutMs = options.timeoutMs ?? defaultCommandTimeoutMs();
     const finish = (result) => {
@@ -3772,22 +3803,47 @@ async function runCommand(executable, args, options = {}) {
       if (killTimer) {
         clearTimeout(killTimer);
       }
+      if (killEscalationTimer) {
+        clearTimeout(killEscalationTimer);
+      }
       if (result.exitCode !== 0 && options.allowFailure !== true) {
         rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
         return;
       }
       resolvePromise(result);
     };
+    const child = (0, import_node_child_process.execFile)(
+      executable,
+      [...args],
+      {
+        cwd: options.cwd,
+        encoding: "utf8",
+        maxBuffer: maxOutputBytes
+      },
+      (err, stdout2, stderr) => {
+        finish(
+          commandResultFromExecFileCallback({
+            args,
+            err,
+            executable,
+            failureMessage,
+            maxOutputBytes,
+            stderr,
+            stdout: stdout2
+          })
+        );
+      }
+    );
     const failAndKill = (message) => {
-      if (failureResult) {
+      if (failureMessage) {
         return;
       }
-      failureResult = { exitCode: 124, stderr: message, stdout: stdoutChunks.join("") };
+      failureMessage = message;
       if (!sentTerminationSignal) {
         sentTerminationSignal = true;
         child.kill("SIGTERM");
       }
-      setTimeout(() => {
+      killEscalationTimer = setTimeout(() => {
         if (!finished) {
           child.kill("SIGKILL");
         }
@@ -3799,54 +3855,20 @@ async function runCommand(executable, args, options = {}) {
       }, timeoutMs);
       killTimer.unref?.();
     }
-    child.stdout.on("data", (chunk) => {
-      if (failureResult) {
-        return;
-      }
-      const text = String(chunk);
-      stdoutBytes += Buffer.byteLength(text);
-      if (stdoutBytes + stderrBytes > maxOutputBytes) {
-        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
-        return;
-      }
-      stdoutChunks.push(text);
-    });
-    child.stderr.on("data", (chunk) => {
-      if (failureResult) {
-        return;
-      }
-      const text = String(chunk);
-      stderrBytes += Buffer.byteLength(text);
-      if (stdoutBytes + stderrBytes > maxOutputBytes) {
-        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
-        return;
-      }
-      stderrChunks.push(text);
-    });
-    child.on("error", (err) => {
-      if (finished) {
-        return;
-      }
-      if (killTimer) {
-        clearTimeout(killTimer);
-      }
-      if (options.allowFailure === true) {
-        finish({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
-      } else {
-        finished = true;
-        rejectPromise(err);
-      }
-    });
-    child.on("close", (code) => {
-      const result = failureResult ?? {
-        exitCode: code ?? 1,
-        stderr: stderrChunks.join(""),
-        stdout: stdoutChunks.join("")
-      };
-      finish(result);
-    });
   });
 }
+function commandResultFromExecFileCallback(params) {
+  if (params.failureMessage) {
+    return { exitCode: 124, stderr: params.failureMessage, stdout: params.stdout };
+  }
+  if (!params.err) {
+    return { exitCode: 0, stderr: params.stderr, stdout: params.stdout };
+  }
+  const error = params.err;
+  const exitCode = typeof error.code === "number" ? error.code : error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ? 124 : 127;
+  const stderr = error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ? `${formatShellCommand(params.executable, params.args)} exceeded output limit of ${params.maxOutputBytes} bytes` : params.stderr || errorMessage(error);
+  return { exitCode, stderr, stdout: params.stdout };
+}
 function defaultCommandTimeoutMs() {
   return positiveIntegerFromEnv("THREADNOTE_COMMAND_TIMEOUT_MS") ?? 10 * 60 * 1e3;
 }
@@ -4773,8 +4795,8 @@ function existsSyncDirectory(path) {
 }
 
 // src/memory.ts
-var import_promises5 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path7 = require("node:path");
 
 // src/manifest.ts
 var import_promises3 = require("node:fs/promises");
@@ -7472,8 +7494,311 @@ function readStringArray(object, key) {
   return value;
 }
 
-// src/memory_hygiene.ts
+// src/index_repair.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+
+// src/runtime.ts
+var import_node_fs3 = require("node:fs");
+var import_node_os3 = require("node:os");
 var import_node_path3 = require("node:path");
+function getRuntimeConfig(program2, manifestOverride) {
+  const options = program2.opts();
+  const threadnoteHome = expandPath(options.home ?? process.env.THREADNOTE_HOME ?? "~/.openviking");
+  const manifestPath = expandPath(
+    manifestOverride ?? options.manifest ?? process.env.THREADNOTE_MANIFEST ?? defaultManifestPath(threadnoteHome)
+  );
+  return {
+    account: process.env.THREADNOTE_ACCOUNT ?? DEFAULT_ACCOUNT,
+    agentContextHome: threadnoteHome,
+    agentId: process.env.THREADNOTE_AGENT_ID ?? DEFAULT_AGENT_ID,
+    host: options.host ?? process.env.THREADNOTE_HOST ?? DEFAULT_HOST,
+    manifestPath,
+    openVikingVersion: process.env.THREADNOTE_OPENVIKING_VERSION ?? DEFAULT_OPENVIKING_VERSION,
+    port: options.port ?? parsePort(process.env.THREADNOTE_PORT ?? String(DEFAULT_PORT)),
+    user: process.env.THREADNOTE_USER ?? (0, import_node_os3.userInfo)().username
+  };
+}
+function defaultManifestPath(agentContextHome) {
+  const userManifest = (0, import_node_path3.join)(agentContextHome, USER_MANIFEST_NAME);
+  return (0, import_node_fs3.existsSync)(userManifest) ? userManifest : builtInExampleManifestPath();
+}
+function builtInExampleManifestPath() {
+  return (0, import_node_path3.join)(toolRoot(), "config", "seed-manifest.example.yaml");
+}
+function openVikingHealthUrl(config) {
+  return `http://${config.host}:${config.port}/health`;
+}
+function openVikingLogPath(config) {
+  return (0, import_node_path3.join)(config.agentContextHome, "logs", "server.log");
+}
+function openVikingServerArgs(config) {
+  return ["--config", (0, import_node_path3.join)(config.agentContextHome, "ov.conf"), "--host", config.host, "--port", String(config.port)];
+}
+function withIdentity(config, args) {
+  return [...args, "--account", config.account, "--user", config.user, "--agent-id", config.agentId];
+}
+function renderTemplate(template, config, extras = {}) {
+  let rendered = template.replaceAll("{{THREADNOTE_HOME}}", config.agentContextHome).replaceAll("{{OPENVIKING_ACCOUNT}}", config.account).replaceAll("{{OPENVIKING_AGENT_ID}}", config.agentId).replaceAll("{{OPENVIKING_HOST}}", config.host).replaceAll("{{OPENVIKING_PORT}}", String(config.port)).replaceAll("{{OPENVIKING_USER}}", config.user);
+  for (const [key, value] of Object.entries(extras)) {
+    rendered = rendered.replaceAll(`{{${key}}}`, () => value);
+  }
+  return rendered;
+}
+
+// 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;
+var MAINTENANCE_COLLAPSE_DEPTH = 3;
+var MAINTENANCE_MAX_REPAIR_TARGETS = 512;
+async function repairStaleRecallIndex(config, ov, options = {}) {
+  options.onProgress?.({ type: "scan-start" });
+  const targets = await findStaleRecallIndexTargets(config, options);
+  const repairTargets = targets.slice(0, options.maxTargets ?? MAX_REPAIR_TARGETS);
+  options.onProgress?.({
+    repairTargetCount: repairTargets.length,
+    totalTargets: targets.length,
+    type: "scan-complete"
+  });
+  if (targets.length === 0) {
+    return { repairedUris: [], skippedRecentUris: [], warnings: [] };
+  }
+  const state = options.dryRun === true ? { entries: {}, version: 1 } : await readAutoRepairState(config);
+  const now = Date.now();
+  const repairedUris = [];
+  const skippedRecentUris = [];
+  const warnings = [];
+  for (const [targetIndex, target] of repairTargets.entries()) {
+    const progressBase = { index: targetIndex + 1, target, total: repairTargets.length };
+    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) {
+      options.onProgress?.({ ...progressBase, type: "repair-skip-recent" });
+      skippedRecentUris.push(target.uri);
+      continue;
+    }
+    if (options.dryRun === true) {
+      options.onProgress?.({ ...progressBase, type: "repair-dry-run" });
+      repairedUris.push(target.uri);
+      continue;
+    }
+    options.onProgress?.({ ...progressBase, type: "repair-start" });
+    const result = await runCommand(
+      ov,
+      withIdentity(config, ["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));
+      await options.onRepairFailure?.(target, result);
+    }
+  }
+  if (options.dryRun !== true && repairedUris.length > 0) {
+    await writeAutoRepairState(config, state);
+  }
+  return { repairedUris, skippedRecentUris, warnings };
+}
+async function findStaleRecallIndexTargets(config, options = {}) {
+  const roots = await scanRoots(config, 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) {
+      for (const sidecar of sidecars) {
+        const uri = collapseStaleSidecarUri(root.uri, sidecar.relativePath, options.collapseDepth);
+        const current = byUri.get(uri) ?? { parts: [], staleCount: 0, uri };
+        current.parts.push(`${sidecar.relativePath}
+${sidecar.content}`);
+        current.staleCount += 1;
+        byUri.set(uri, current);
+      }
+      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 collapseStaleSidecarUri(rootUri, relativePath, depth = 0) {
+  const normalizedRootUri = trimLocalRootUri(rootUri);
+  if (depth <= 0) {
+    return normalizedRootUri;
+  }
+  const parentParts = relativePath.split("/").slice(0, -1);
+  const collapsedParts = parentParts.slice(0, depth);
+  return collapsedParts.length === 0 ? normalizedRootUri : `${normalizedRootUri}/${collapsedParts.join("/")}`;
+}
+function formatRecallIndexRepairMessages(result, options = {}) {
+  const messages = [];
+  const maxUris = options.maxUris ?? result.repairedUris.length;
+  for (const uri of result.repairedUris.slice(0, maxUris)) {
+    messages.push(
+      `${options.dryRun === true ? "Would auto-reindex stale recall scope" : "Auto-reindexed stale recall scope"}: ${uri}`
+    );
+  }
+  const hiddenUriCount = result.repairedUris.length - maxUris;
+  if (hiddenUriCount > 0) {
+    messages.push(
+      options.dryRun === true ? `Would auto-reindex ${hiddenUriCount} more stale recall scope(s).` : `Auto-reindexed ${hiddenUriCount} more stale recall scope(s).`
+    );
+  }
+  for (const warning2 of result.warnings) {
+    messages.push(`Auto-index repair warning: ${warning2}`);
+  }
+  return messages;
+}
+function filterStaleRecallSummaryRows(output2) {
+  return output2.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(config, options) {
+  const accountRoot = (0, import_node_path4.join)(config.agentContextHome, "data", "viking", config.account);
+  const roots = [
+    {
+      path: (0, import_node_path4.join)(accountRoot, "user", uriSegment(config.user), "memories"),
+      uri: `viking://user/${uriSegment(config.user)}/memories`
+    }
+  ];
+  const query = options.query;
+  if (query) {
+    const project = await inferProjectFromQuery(config.manifestPath, query);
+    const projectPath = project?.uri.startsWith("viking://resources/") ? (0, import_node_path4.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(config, accountRoot));
+  }
+  const scanAgentSkills = options.includeAgentSkills === true || (query ? /\bskills?\b/.test(query.toLowerCase()) : false);
+  if (scanAgentSkills) {
+    roots.push({ path: (0, import_node_path4.join)(accountRoot, "resources", "agent-skills"), uri: "viking://resources/agent-skills" });
+  }
+  return dedupeRoots(roots);
+}
+async function manifestResourceRoots(config, accountRoot) {
+  try {
+    const manifest = await readSeedManifest(config.manifestPath);
+    return manifest.projects.filter((project) => project.uri.startsWith("viking://resources/")).map((project) => ({
+      path: (0, import_node_path4.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_promises4.readdir)(path, { withFileTypes: true });
+    } catch (_err) {
+      return;
+    }
+    for (const entry of entries) {
+      const childPath = (0, import_node_path4.join)(path, entry.name);
+      if (entry.isFile() && isSummarySidecar(entry.name)) {
+        let content;
+        try {
+          content = await (0, import_promises4.readFile)(childPath, "utf8");
+        } catch (_err) {
+          continue;
+        }
+        if (!isStaleSummary(content)) {
+          continue;
+        }
+        const parentPath = (0, import_node_path4.dirname)(childPath);
+        const parentRelative = toPosixPath((0, import_node_path4.relative)(rootPath, parentPath));
+        const relativePath = toPosixPath((0, import_node_path4.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(config) {
+  const raw = await readFileIfExists(autoRepairStatePath(config));
+  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(config, state) {
+  const path = autoRepairStatePath(config);
+  await ensureDirectory((0, import_node_path4.dirname)(path), false);
+  await (0, import_promises4.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+function autoRepairStatePath(config) {
+  return (0, import_node_path4.join)(config.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_path5 = require("node:path");
 var HYGIENE_SOURCES_HEADING = "## Threadnote Hygiene Sources";
 var STALE_HANDOFF_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
 function parseMemoryDocument(uri, content) {
@@ -7766,7 +8091,7 @@ function branchFromBody(body) {
   return branch?.split(/\s+/)[0]?.replace(/[.,;:]+$/g, "");
 }
 function topicFromUri(uri) {
-  const name = (0, import_node_path3.basename)(uri).replace(/\.md$/, "");
+  const name = (0, import_node_path5.basename)(uri).replace(/\.md$/, "");
   return name.startsWith("threadnote-") ? void 0 : name;
 }
 function parseProjectFromUri(uri) {
@@ -7796,7 +8121,7 @@ function preferredKeepRecord(records, topic) {
 }
 function isStableRecord(record, topic) {
   const recordTopic = topic ?? topicForRecord(record);
-  return recordTopic !== void 0 && (0, import_node_path3.basename)(record.uri) === `${uriSegment(recordTopic)}.md`;
+  return recordTopic !== void 0 && (0, import_node_path5.basename)(record.uri) === `${uriSegment(recordTopic)}.md`;
 }
 function sortedNewestFirst(records) {
   return [...records].sort((left, right) => {
@@ -7907,58 +8232,10 @@ function formatPlanSection(title, lines) {
   return [`${title}:`, ...lines.map((line) => `- ${line}`)].join("\n");
 }
 
-// src/runtime.ts
-var import_node_fs3 = require("node:fs");
-var import_node_os3 = require("node:os");
-var import_node_path4 = require("node:path");
-function getRuntimeConfig(program2, manifestOverride) {
-  const options = program2.opts();
-  const threadnoteHome = expandPath(options.home ?? process.env.THREADNOTE_HOME ?? "~/.openviking");
-  const manifestPath = expandPath(
-    manifestOverride ?? options.manifest ?? process.env.THREADNOTE_MANIFEST ?? defaultManifestPath(threadnoteHome)
-  );
-  return {
-    account: process.env.THREADNOTE_ACCOUNT ?? DEFAULT_ACCOUNT,
-    agentContextHome: threadnoteHome,
-    agentId: process.env.THREADNOTE_AGENT_ID ?? DEFAULT_AGENT_ID,
-    host: options.host ?? process.env.THREADNOTE_HOST ?? DEFAULT_HOST,
-    manifestPath,
-    openVikingVersion: process.env.THREADNOTE_OPENVIKING_VERSION ?? DEFAULT_OPENVIKING_VERSION,
-    port: options.port ?? parsePort(process.env.THREADNOTE_PORT ?? String(DEFAULT_PORT)),
-    user: process.env.THREADNOTE_USER ?? (0, import_node_os3.userInfo)().username
-  };
-}
-function defaultManifestPath(agentContextHome) {
-  const userManifest = (0, import_node_path4.join)(agentContextHome, USER_MANIFEST_NAME);
-  return (0, import_node_fs3.existsSync)(userManifest) ? userManifest : builtInExampleManifestPath();
-}
-function builtInExampleManifestPath() {
-  return (0, import_node_path4.join)(toolRoot(), "config", "seed-manifest.example.yaml");
-}
-function openVikingHealthUrl(config) {
-  return `http://${config.host}:${config.port}/health`;
-}
-function openVikingLogPath(config) {
-  return (0, import_node_path4.join)(config.agentContextHome, "logs", "server.log");
-}
-function openVikingServerArgs(config) {
-  return ["--config", (0, import_node_path4.join)(config.agentContextHome, "ov.conf"), "--host", config.host, "--port", String(config.port)];
-}
-function withIdentity(config, args) {
-  return [...args, "--account", config.account, "--user", config.user, "--agent-id", config.agentId];
-}
-function renderTemplate(template, config, extras = {}) {
-  let rendered = template.replaceAll("{{THREADNOTE_HOME}}", config.agentContextHome).replaceAll("{{OPENVIKING_ACCOUNT}}", config.account).replaceAll("{{OPENVIKING_AGENT_ID}}", config.agentId).replaceAll("{{OPENVIKING_HOST}}", config.host).replaceAll("{{OPENVIKING_PORT}}", String(config.port)).replaceAll("{{OPENVIKING_USER}}", config.user);
-  for (const [key, value] of Object.entries(extras)) {
-    rendered = rendered.replaceAll(`{{${key}}}`, () => value);
-  }
-  return rendered;
-}
-
 // src/share.ts
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_os4 = require("node:os");
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
 var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
@@ -8027,8 +8304,8 @@ async function runShareInit(config, remoteUrl, options) {
   if (await exists(gitdir)) {
     throw new Error(`Gitdir already exists at ${gitdir}; remove it or pick a different team name.`);
   }
-  await ensureDirectory((0, import_node_path5.dirname)(worktree), dryRun);
-  await ensureDirectory((0, import_node_path5.dirname)(gitdir), dryRun);
+  await ensureDirectory((0, import_node_path6.dirname)(worktree), dryRun);
+  await ensureDirectory((0, import_node_path6.dirname)(gitdir), dryRun);
   const git = await requiredExecutable("git");
   await maybeRun(dryRun, git, ["clone", `--separate-git-dir=${gitdir}`, "--", remoteUrl, worktree]);
   const newConfig = {
@@ -8059,7 +8336,7 @@ async function runShareInit(config, remoteUrl, options) {
 var SHARED_GITIGNORE_PATTERNS = ["**/.abstract.md", "**/.overview.md"];
 var SHARED_GITIGNORE_HEADER = "# Threadnote: ignore OpenViking-generated directory summaries.";
 async function ensureSharedGitignore(worktree, git, push) {
-  const gitignorePath = (0, import_node_path5.join)(worktree, ".gitignore");
+  const gitignorePath = (0, import_node_path6.join)(worktree, ".gitignore");
   const existing = await readFileIfExists(gitignorePath) ?? "";
   const lines = existing.split("\n").map((line) => line.trim());
   const missingPatterns = SHARED_GITIGNORE_PATTERNS.filter((pattern) => !lines.includes(pattern));
@@ -8078,7 +8355,7 @@ async function ensureSharedGitignore(worktree, git, push) {
     segments.push(SHARED_GITIGNORE_HEADER, "\n");
   }
   segments.push(missingPatterns.join("\n"), "\n");
-  await (0, import_promises4.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
+  await (0, import_promises5.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
   console.log(`Added ${missingPatterns.join(", ")} to ${portablePath(gitignorePath)}`);
   await maybeRun(false, git, ["-C", worktree, "add", ".gitignore"]);
   const commitResult = await runCommand(
@@ -8160,7 +8437,7 @@ function autoShareState(config) {
   return state;
 }
 function pendingReindexesPath(config) {
-  return (0, import_node_path5.join)(config.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+  return (0, import_node_path6.join)(config.agentContextHome, "share", "auto-sync-pending-reindexes.json");
 }
 async function loadPendingReindexes(config, state) {
   const raw = await readFileIfExists(pendingReindexesPath(config));
@@ -8197,18 +8474,18 @@ async function loadPendingReindexes(config, state) {
 async function writePendingReindexes(config, state) {
   const path = pendingReindexesPath(config);
   if (state.pendingReindexes.size === 0) {
-    await (0, import_promises4.rm)(path, { force: true });
+    await (0, import_promises5.rm)(path, { force: true });
     return;
   }
   const contents = {
     teams: Object.fromEntries(state.pendingReindexes),
     version: 1
   };
-  await (0, import_promises4.mkdir)((0, import_node_path5.dirname)(path), { recursive: true });
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
-  await (0, import_promises4.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
+  await (0, import_promises5.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await (0, import_promises4.rename)(tempPath, path);
+  await (0, import_promises5.rename)(tempPath, path);
 }
 async function refreshShareUpdateStateLocked(config, state, options) {
   const now = Date.now();
@@ -8297,7 +8574,7 @@ async function runShareSync(config, options) {
   if (dryRun) {
     console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME])}`);
   } else if (pullResult && pullResult.exitCode !== 0) {
-    if (await exists((0, import_node_path5.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path5.join)(team.config.gitdir, "rebase-apply"))) {
+    if (await exists((0, import_node_path6.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path6.join)(team.config.gitdir, "rebase-apply"))) {
       throw new Error(
         `git pull --rebase reported conflicts in ${worktree}. The worktree is in a rebase-in-progress state.
 Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then re-run \`threadnote share sync\`.`
@@ -8359,7 +8636,7 @@ async function runShareSyncQuiet(config, 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_path5.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path5.join)(team.config.gitdir, "rebase-apply"))) {
+    if (await exists((0, import_node_path6.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path6.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.`
       );
@@ -8598,8 +8875,8 @@ async function runShareRename(config, options) {
     console.log(`Would write teams file: ${teamsFilePath(config)}`);
     return;
   }
-  await (0, import_promises4.rename)(oldTeam.config.worktree, newWorktree);
-  await (0, import_promises4.rename)(oldTeam.config.gitdir, newGitdir);
+  await (0, import_promises5.rename)(oldTeam.config.worktree, newWorktree);
+  await (0, import_promises5.rename)(oldTeam.config.gitdir, newGitdir);
   await writeTeamsFile(config, updatedFile);
   const git = await requiredExecutable("git");
   await runCommand(git, ["-C", newWorktree, "config", "core.worktree", newWorktree]);
@@ -8681,12 +8958,12 @@ async function preserveSharedMemoriesLocally(config, team, dryRun) {
   const files = await walkMemoryFiles(team.worktree);
   let preserved = 0;
   for (const file of files) {
-    const rel = (0, import_node_path5.relative)(team.worktree, file).split(import_node_path5.sep).join("/");
+    const rel = (0, import_node_path6.relative)(team.worktree, file).split(import_node_path6.sep).join("/");
     if (!rel.startsWith("durable/")) {
       continue;
     }
     const targetUri = `viking://user/${uriSegment(config.user)}/memories/${rel}`;
-    const content = await (0, import_promises4.readFile)(file, "utf8");
+    const content = await (0, import_promises5.readFile)(file, "utf8");
     if (dryRun) {
       console.log(`Would preserve ${rel} -> ${targetUri}`);
     } else {
@@ -8725,10 +9002,10 @@ function normalizeTeamName(input2) {
   return candidate;
 }
 function teamsFilePath(config) {
-  return (0, import_node_path5.join)(config.agentContextHome, "share", "teams.json");
+  return (0, import_node_path6.join)(config.agentContextHome, "share", "teams.json");
 }
 function teamWorktreePath(config, team) {
-  return (0, import_node_path5.join)(
+  return (0, import_node_path6.join)(
     config.agentContextHome,
     "data",
     "viking",
@@ -8741,7 +9018,7 @@ function teamWorktreePath(config, team) {
   );
 }
 function teamGitdirPath(config, team) {
-  return (0, import_node_path5.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
+  return (0, import_node_path6.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
 async function readTeamsFile(config) {
   const path = teamsFilePath(config);
@@ -8784,13 +9061,13 @@ async function readTeamsFile(config) {
 }
 async function writeTeamsFile(config, contents) {
   const path = teamsFilePath(config);
-  await (0, import_promises4.mkdir)((0, import_node_path5.dirname)(path), { recursive: true });
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(path), { recursive: true });
   const serializable = {
     defaultTeam: contents.defaultTeam,
     teams: contents.teams,
     version: contents.version
   };
-  await (0, import_promises4.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
+  await (0, import_promises5.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function resolveTeam(config, requested) {
@@ -8820,7 +9097,7 @@ async function assertWorktreeUsable(worktree) {
   if (!await isDirectory(worktree)) {
     throw new Error(`Cannot use ${worktree} as a worktree: not a directory.`);
   }
-  const entries = await (0, import_promises4.readdir)(worktree);
+  const entries = await (0, import_promises5.readdir)(worktree);
   if (entries.length > 0) {
     const preview = entries.slice(0, 5).join(", ");
     const suffix = entries.length > 5 ? `, +${entries.length - 5} more` : "";
@@ -8844,7 +9121,7 @@ async function walkMemoryFiles(root) {
   async function visit(path, depth) {
     let entries;
     try {
-      entries = await (0, import_promises4.readdir)(path, { withFileTypes: true });
+      entries = await (0, import_promises5.readdir)(path, { withFileTypes: true });
     } catch (err) {
       console.warn(`Skipping ${path} during shared-tree walk: ${err instanceof Error ? err.message : String(err)}`);
       return;
@@ -8853,7 +9130,7 @@ async function walkMemoryFiles(root) {
       if (entry.name === ".git") {
         continue;
       }
-      const full = (0, import_node_path5.join)(path, entry.name);
+      const full = (0, import_node_path6.join)(path, entry.name);
       if (entry.isDirectory()) {
         if (depth === 0 && !SHAREABLE_MEMORY_KIND_DIRS.includes(entry.name)) {
           continue;
@@ -8877,7 +9154,7 @@ async function walkMemoryFiles(root) {
   return out;
 }
 function workfileToVikingUri(config, team, filePath) {
-  const rel = (0, import_node_path5.relative)(team.worktree, filePath).split(import_node_path5.sep).join("/");
+  const rel = (0, import_node_path6.relative)(team.worktree, filePath).split(import_node_path6.sep).join("/");
   return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config, uri) {
@@ -9025,13 +9302,14 @@ async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun, op
     }
     return;
   }
-  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path5.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path5.join)(stagingDir, "body.txt");
+  const stagingDir = await (0, import_promises5.mkdtemp)((0, import_node_path6.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path6.join)(stagingDir, "body.txt");
   try {
-    await (0, import_promises4.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await (0, import_promises5.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config, ov, uri, tempPath, initialMode, options);
+    await refreshMemoryIndex(config, ov, uri, options);
   } finally {
-    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises5.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
@@ -9086,6 +9364,27 @@ async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, opti
     }
   }
 }
+async function refreshMemoryIndex(config, ov, uri, options = {}) {
+  const result = await runCommand(
+    ov,
+    withIdentity(config, ["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, config, options = {}) {
   const result = await runCommand(ov, withIdentity(config, ["wait", "--timeout", "120"]), { allowFailure: true });
   if (options.quiet !== true && result.stdout.trim()) {
@@ -9106,7 +9405,7 @@ ${stdout2}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed");
 }
 async function ingestSingleFile(ov, config, uri, filePath, initialMode, options = {}) {
-  const content = await (0, import_promises4.readFile)(filePath, "utf8");
+  const content = await (0, import_promises5.readFile)(filePath, "utf8");
   await writeMemoryFile(config, ov, uri, content, initialMode, false, options);
 }
 async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
@@ -9171,8 +9470,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_path5.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path5.join)(worktree, newRel), relativePath: newRel, status: "added" });
+        changes.push({ path: (0, import_node_path6.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path6.join)(worktree, newRel), relativePath: newRel, status: "added" });
       }
       index += 3;
       continue;
@@ -9180,7 +9479,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_path5.join)(worktree, rel), relativePath: rel, status });
+      changes.push({ path: (0, import_node_path6.join)(worktree, rel), relativePath: rel, status });
     }
     index += 2;
   }
@@ -9302,7 +9601,7 @@ async function runMigrateMemories(config, options) {
   const candidates = await legacyMemoryCandidates(config, sourceAccounts);
   const existingHashes = await existingDurableMemoryHashes(config);
   const ov = await openVikingCliForMode(dryRun);
-  const migrationPath = (0, import_node_path6.join)(config.agentContextHome, "legacy-memory-migration.txt");
+  const migrationPath = (0, import_node_path7.join)(config.agentContextHome, "legacy-memory-migration.txt");
   let duplicateCount = 0;
   let migratedCount = 0;
   let sensitiveCount = 0;
@@ -9338,8 +9637,8 @@ async function runMigrateMemories(config, options) {
       }
       console.log(`${dryRun ? "Would migrate" : "Migrating"} ${legacySourceLabel(candidate)} -> ${memoryUri}`);
       if (!dryRun) {
-        await (0, import_promises5.writeFile)(migrationPath, candidate.text, { encoding: "utf8", mode: 384 });
-        await (0, import_promises5.chmod)(migrationPath, 384);
+        await (0, import_promises6.writeFile)(migrationPath, candidate.text, { encoding: "utf8", mode: 384 });
+        await (0, import_promises6.chmod)(migrationPath, 384);
         await writeDurableMemoryFile(ov, config, memoryUri, migrationPath, "create");
         existingHashes.add(candidate.hash);
       }
@@ -9347,7 +9646,7 @@ async function runMigrateMemories(config, options) {
     }
   } finally {
     if (!dryRun) {
-      await (0, import_promises5.rm)(migrationPath, { force: true });
+      await (0, import_promises6.rm)(migrationPath, { force: true });
     }
   }
   console.log(
@@ -9365,7 +9664,7 @@ async function runMigrateLifecycle(config, options) {
   const limit = options.limit ? parsePositiveInteger(options.limit, "lifecycle migration limit") : void 0;
   const ov = await openVikingCliForMode(dryRun);
   const candidates = await legacyLifecycleHandoffCandidates(config);
-  const migrationPath = (0, import_node_path6.join)(config.agentContextHome, "lifecycle-memory-migration.txt");
+  const migrationPath = (0, import_node_path7.join)(config.agentContextHome, "lifecycle-memory-migration.txt");
   let existingCount = 0;
   let migratedCount = 0;
   let skippedCount = 0;
@@ -9386,8 +9685,8 @@ async function runMigrateLifecycle(config, options) {
           existingCount += 1;
           console.log(`Archived copy already exists; cleaning up legacy source: ${candidate.sourceUri}`);
         } else {
-          await (0, import_promises5.writeFile)(migrationPath, migratedMemory, { encoding: "utf8", mode: 384 });
-          await (0, import_promises5.chmod)(migrationPath, 384);
+          await (0, import_promises6.writeFile)(migrationPath, migratedMemory, { encoding: "utf8", mode: 384 });
+          await (0, import_promises6.chmod)(migrationPath, 384);
           await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, candidate.metadata));
           await writeDurableMemoryFile(ov, config, destinationUri, migrationPath, "create");
         }
@@ -9403,7 +9702,7 @@ async function runMigrateLifecycle(config, options) {
     }
   } finally {
     if (!dryRun) {
-      await (0, import_promises5.rm)(migrationPath, { force: true });
+      await (0, import_promises6.rm)(migrationPath, { force: true });
     }
   }
   console.log(
@@ -9423,6 +9722,19 @@ async function runRecall(config, options) {
   const ov = await openVikingCliForMode(options.dryRun === true);
   const query = await enrichRecallQueryWithWorkspaceContext(options.query);
   const projectQuery = await enrichRecallQueryWithWorkspaceProjectContext(options.query);
+  let indexRepairMessages;
+  try {
+    const indexRepair = await repairStaleRecallIndex(config, ov, {
+      dryRun: options.dryRun === true,
+      query: projectQuery
+    });
+    indexRepairMessages = formatRecallIndexRepairMessages(indexRepair, { dryRun: options.dryRun === true });
+  } catch (err) {
+    indexRepairMessages = [`Auto-index repair warning: ${err instanceof Error ? err.message : String(err)}`];
+  }
+  for (const message of indexRepairMessages) {
+    console.log(message);
+  }
   const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, projectQuery));
   const args = ["search", query];
   if (inferredUri) {
@@ -9433,9 +9745,9 @@ async function runRecall(config, options) {
     args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
   }
   const recallOutputs = [];
-  const baseResult = await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
-  if (baseResult) {
-    recallOutputs.push([baseResult.stdout.trim(), baseResult.stderr.trim()].filter(Boolean).join("\n"));
+  const baseOutput = await runRecallSearch(config, ov, args, { dryRun: options.dryRun === true });
+  if (baseOutput) {
+    recallOutputs.push(baseOutput);
   }
   const seededOutput = await augmentRecallWithSeededResources(
     config,
@@ -9474,8 +9786,20 @@ async function augmentRecallWithSeededResources(config, ov, options, inferredUri
   }
   console.log(`
 Also searching seeded resources: ${projectResourceUri}`);
-  const result = await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
-  return result ? [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n") : void 0;
+  return runRecallSearch(config, ov, args, { dryRun: options.dryRun === true });
+}
+async function runRecallSearch(config, ov, args, options) {
+  const fullArgs = withIdentity(config, args);
+  console.log(`${options.dryRun ? "Would run" : "Running"}: ${formatShellCommand(ov, fullArgs)}`);
+  if (options.dryRun) {
+    return void 0;
+  }
+  const result = await runCommand(ov, fullArgs);
+  const output2 = filterStaleRecallSummaryRows([result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n"));
+  if (output2) {
+    console.log(output2);
+  }
+  return output2 || void 0;
 }
 async function runRead(config, uri, options) {
   assertVikingUri(uri);
@@ -9541,15 +9865,15 @@ async function runCompact(config, options) {
     return;
   }
   const ov = await openVikingCliForMode(false);
-  const updatePath = (0, import_node_path6.join)(config.agentContextHome, "compact-memory-update.txt");
+  const updatePath = (0, import_node_path7.join)(config.agentContextHome, "compact-memory-update.txt");
   try {
     for (const action of plan.keepUpdates) {
-      await (0, import_promises5.writeFile)(updatePath, action.content, { encoding: "utf8", mode: 384 });
-      await (0, import_promises5.chmod)(updatePath, 384);
+      await (0, import_promises6.writeFile)(updatePath, action.content, { encoding: "utf8", mode: 384 });
+      await (0, import_promises6.chmod)(updatePath, 384);
       await writeDurableMemoryFile(ov, config, action.uri, updatePath, "replace");
     }
   } finally {
-    await (0, import_promises5.rm)(updatePath, { force: true });
+    await (0, import_promises6.rm)(updatePath, { force: true });
   }
   for (const action of plan.archives) {
     await runArchive(config, action.uri, {
@@ -9605,7 +9929,7 @@ async function scopedCompactRecords(config, options) {
     const uriDirectory = memoryUriDirectoryForCompact(config, kind, options.project);
     let entries;
     try {
-      entries = await (0, import_promises5.readdir)(directory, { withFileTypes: true });
+      entries = await (0, import_promises6.readdir)(directory, { withFileTypes: true });
     } catch (_err) {
       continue;
     }
@@ -9613,7 +9937,7 @@ async function scopedCompactRecords(config, options) {
       if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
         continue;
       }
-      const content = await readTextIfExists((0, import_node_path6.join)(directory, entry.name));
+      const content = await readTextIfExists((0, import_node_path7.join)(directory, entry.name));
       if (!content) {
         continue;
       }
@@ -9651,11 +9975,11 @@ function localMemoryDirectoryForCompact(config, kind, project) {
   const projectSegment = uriSegment(project);
   switch (kind) {
     case "durable":
-      return (0, import_node_path6.join)(root, "durable", "projects", projectSegment);
+      return (0, import_node_path7.join)(root, "durable", "projects", projectSegment);
     case "handoff":
-      return (0, import_node_path6.join)(root, "handoffs", "active", projectSegment);
+      return (0, import_node_path7.join)(root, "handoffs", "active", projectSegment);
     case "incident":
-      return (0, import_node_path6.join)(root, "incidents", "active", projectSegment);
+      return (0, import_node_path7.join)(root, "incidents", "active", projectSegment);
   }
 }
 function memoryUriDirectoryForCompact(config, kind, project) {
@@ -9675,11 +9999,11 @@ function localMemoryPathForUri(config, uri) {
   if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
     return void 0;
   }
-  const relative4 = uri.slice(prefix.length);
-  if (relative4.includes("..") || relative4.startsWith("/")) {
+  const relative5 = uri.slice(prefix.length);
+  if (relative5.includes("..") || relative5.startsWith("/")) {
     return void 0;
   }
-  return (0, import_node_path6.join)(localUserMemoriesRoot(config), ...relative4.split("/"));
+  return (0, import_node_path7.join)(localUserMemoriesRoot(config), ...relative5.split("/"));
 }
 async function runList(config, uri, options) {
   assertVikingUri(uri);
@@ -9773,7 +10097,7 @@ async function runForget(config, uri, options) {
 }
 async function runExportPack(config, options) {
   const ov = await openVikingCliForMode(options.dryRun === true);
-  const defaultPath = (0, import_node_path6.join)(config.agentContextHome, `threadnote-${safeTimestamp()}.ovpack`);
+  const defaultPath = (0, import_node_path7.join)(config.agentContextHome, `threadnote-${safeTimestamp()}.ovpack`);
   const outputPath = expandPath(options.path ?? defaultPath);
   await maybeRun(options.dryRun === true, ov, withIdentity(config, ["export", options.uri ?? "viking://", outputPath]));
 }
@@ -9789,12 +10113,25 @@ async function runImportPack(config, options) {
   );
 }
 async function inferRecallUri(config, query) {
-  if (!/\bskills?\b/.test(query.toLowerCase())) {
+  if (!hasAgentSkillCatalogIntent(query)) {
     return void 0;
   }
   const project = await inferProjectFromQuery(config.manifestPath, query);
   return project ? `viking://resources/agent-skills/repo-local-${uriSegment(project.name)}` : "viking://resources/agent-skills";
 }
+function hasAgentSkillCatalogIntent(query) {
+  const normalized = query.toLowerCase();
+  if (!/\bskills?\b/.test(normalized)) {
+    return false;
+  }
+  if (/\bseed[- ]skills?\b/.test(normalized) || /\bskills?\s+seed(?:ing)?\b/.test(normalized)) {
+    return false;
+  }
+  if (/^\s*skills?\s*$/.test(normalized)) {
+    return true;
+  }
+  return /\b(find|list|show|search|recall|use|choose|select)\b.{0,48}\bskills?\b/.test(normalized) || /\bskills?\b.{0,48}\b(for|to|that|which|about)\b/.test(normalized);
+}
 async function printExactMemoryMatches(config, ov, query, options) {
   const terms = exactRecallTerms(query);
   if (terms.length === 0) {
@@ -9833,7 +10170,7 @@ async function storeMemory(config, options) {
     await storeSharedMemoryReplacement(config, ov, options, options.replaceUri);
     return;
   }
-  const memoryPath = (0, import_node_path6.join)(config.agentContextHome, "last-memory.txt");
+  const memoryPath = (0, import_node_path7.join)(config.agentContextHome, "last-memory.txt");
   const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
   const candidateMemory = formatMemoryDocument2(options.title, candidateMetadata, options.bodyText);
   const memoryUri = memoryUriFor(config, candidateMemory, candidateMetadata);
@@ -9865,8 +10202,8 @@ async function storeMemory(config, options) {
     }
     return;
   }
-  await (0, import_promises5.writeFile)(memoryPath, memory, { encoding: "utf8", mode: 384 });
-  await (0, import_promises5.chmod)(memoryPath, 384);
+  await (0, import_promises6.writeFile)(memoryPath, memory, { encoding: "utf8", mode: 384 });
+  await (0, import_promises6.chmod)(memoryPath, 384);
   await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, finalMetadata));
   await writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode);
   console.log(`Stored memory: ${memoryUri}`);
@@ -9925,7 +10262,7 @@ async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
   console.log(`Updated shared memory: ${targetUri}`);
 }
 async function writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode) {
-  const content = await (0, import_promises5.readFile)(memoryPath, "utf8");
+  const content = await (0, import_promises6.readFile)(memoryPath, "utf8");
   await writeMemoryFile(config, ov, memoryUri, content, writeMode, false);
 }
 async function removeVikingResourceWithRetry(ov, config, uri) {
@@ -9982,10 +10319,10 @@ async function hasLegacyLifecycleHandoffCandidates(config) {
   return (await legacyLifecycleHandoffCandidates(config, 1)).length > 0;
 }
 async function legacyLifecycleHandoffCandidates(config, limit) {
-  const eventsRoot = (0, import_node_path6.join)(localUserMemoriesRoot(config), "events");
+  const eventsRoot = (0, import_node_path7.join)(localUserMemoriesRoot(config), "events");
   let entries;
   try {
-    entries = await (0, import_promises5.readdir)(eventsRoot, { withFileTypes: true });
+    entries = await (0, import_promises6.readdir)(eventsRoot, { withFileTypes: true });
   } catch (_err) {
     return [];
   }
@@ -9994,7 +10331,7 @@ async function legacyLifecycleHandoffCandidates(config, limit) {
     if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
       continue;
     }
-    const sourcePath = (0, import_node_path6.join)(eventsRoot, entry.name);
+    const sourcePath = (0, import_node_path7.join)(eventsRoot, entry.name);
     const original = await readTextIfExists(sourcePath);
     if (!original || !isClearLegacyHandoffMemory(original) || sensitiveMemoryReason(original)) {
       continue;
@@ -10135,7 +10472,7 @@ function inferLegacyProject(memory) {
     return "general";
   }
   const trimmed = explicit.trim().replace(/[`.,;]+$/g, "");
-  return trimmed.includes("/") ? (0, import_node_path6.basename)(trimmed) : trimmed;
+  return trimmed.includes("/") ? (0, import_node_path7.basename)(trimmed) : trimmed;
 }
 function parseOptionalMemoryKind2(value) {
   if (!value) {
@@ -10175,14 +10512,14 @@ async function legacySourceAccounts(config, options) {
 async function legacyMemoryCandidates(config, sourceAccounts) {
   const candidates = [];
   for (const sourceAccount of sourceAccounts) {
-    const sessionRoot = (0, import_node_path6.join)(localVikingDataRoot(config), sourceAccount, "session");
+    const sessionRoot = (0, import_node_path7.join)(localVikingDataRoot(config), sourceAccount, "session");
     for (const sourceSession of await childDirectoryNames(sessionRoot)) {
-      const historyRoot = (0, import_node_path6.join)(sessionRoot, sourceSession, "history");
+      const historyRoot = (0, import_node_path7.join)(sessionRoot, sourceSession, "history");
       for (const sourceArchive of await childDirectoryNames(historyRoot)) {
         if (!sourceArchive.startsWith("archive_")) {
           continue;
         }
-        const sourcePath = (0, import_node_path6.join)(historyRoot, sourceArchive, "messages.jsonl");
+        const sourcePath = (0, import_node_path7.join)(historyRoot, sourceArchive, "messages.jsonl");
         for (const text of await legacyMemoryTexts(sourcePath)) {
           candidates.push({
             comparableHash: sha256(comparableMemoryText(text)),
@@ -10245,12 +10582,12 @@ async function existingDurableMemoryHashes(config) {
 async function collectDurableMemoryHashes(root, hashes) {
   let entries;
   try {
-    entries = await (0, import_promises5.readdir)(root, { withFileTypes: true });
+    entries = await (0, import_promises6.readdir)(root, { withFileTypes: true });
   } catch (_err) {
     return;
   }
   for (const entry of entries) {
-    const path = (0, import_node_path6.join)(root, entry.name);
+    const path = (0, import_node_path7.join)(root, entry.name);
     if (entry.isDirectory()) {
       await collectDurableMemoryHashes(path, hashes);
       continue;
@@ -10267,12 +10604,12 @@ async function collectDurableMemoryHashes(root, hashes) {
   }
 }
 function isDurableMemoryPath(path) {
-  return path.split(import_node_path6.sep).includes("memories");
+  return path.split(import_node_path7.sep).includes("memories");
 }
 async function childDirectoryNames(path) {
   let entries;
   try {
-    entries = await (0, import_promises5.readdir)(path, { withFileTypes: true });
+    entries = await (0, import_promises6.readdir)(path, { withFileTypes: true });
   } catch (_err) {
     return [];
   }
@@ -10280,11 +10617,11 @@ async function childDirectoryNames(path) {
 }
 async function readTextIfExists(path) {
   try {
-    const pathStat = await (0, import_promises5.stat)(path);
+    const pathStat = await (0, import_promises6.stat)(path);
     if (!pathStat.isFile()) {
       return void 0;
     }
-    return await (0, import_promises5.readFile)(path, "utf8");
+    return await (0, import_promises6.readFile)(path, "utf8");
   } catch (_err) {
     return void 0;
   }
@@ -10311,10 +10648,10 @@ function legacySourceLabel(candidate) {
   return `${candidate.sourceAccount}/${candidate.sourceSession}/${candidate.sourceArchive}`;
 }
 function localVikingDataRoot(config) {
-  return (0, import_node_path6.join)(config.agentContextHome, "data", "viking");
+  return (0, import_node_path7.join)(config.agentContextHome, "data", "viking");
 }
 function localUserMemoriesRoot(config) {
-  return (0, import_node_path6.join)(localVikingDataRoot(config), config.account, "user", uriSegment(config.user), "memories");
+  return (0, import_node_path7.join)(localVikingDataRoot(config), config.account, "user", uriSegment(config.user), "memories");
 }
 function uniqueStrings(values) {
   return [...new Set(values)].sort();
@@ -10330,7 +10667,7 @@ async function buildHandoff(options) {
   const status = await gitValue(["status", "--short"], repoRoot) ?? "";
   const diffStat = await gitValue(["diff", "--stat", "HEAD"], repoRoot) ?? "";
   const touchedFiles = await gitTouchedFiles(repoRoot);
-  const repoName = await resolveRepoName(repoRoot) ?? (0, import_node_path6.basename)(repoRoot);
+  const repoName = await resolveRepoName(repoRoot) ?? (0, import_node_path7.basename)(repoRoot);
   const topicBranch = branch && branch !== "unknown" ? branch : "current";
   const metadata = {
     kind: "handoff",
@@ -10390,8 +10727,8 @@ function formatBlock(value, emptyValue) {
 
 // src/update-check.ts
 var import_node_child_process2 = require("node:child_process");
-var import_promises6 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var NPM_LATEST_URL = "https://registry.npmjs.org/threadnote/latest";
 var FETCH_TIMEOUT_MS = 3e3;
@@ -10458,7 +10795,7 @@ function isCacheFresh(cache) {
 }
 async function readUpdateCache(cachePath) {
   try {
-    const raw = await (0, import_promises6.readFile)(cachePath, "utf8");
+    const raw = await (0, import_promises7.readFile)(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
       return void 0;
@@ -10470,8 +10807,8 @@ async function readUpdateCache(cachePath) {
 }
 async function writeUpdateCache(cachePath, contents) {
   try {
-    await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(cachePath), { recursive: true });
-    await (0, import_promises6.writeFile)(cachePath, `${JSON.stringify(contents)}
+    await (0, import_promises7.mkdir)((0, import_node_path8.dirname)(cachePath), { recursive: true });
+    await (0, import_promises7.writeFile)(cachePath, `${JSON.stringify(contents)}
 `, { encoding: "utf8", mode: 384 });
   } catch {
   }
@@ -10494,14 +10831,14 @@ async function fetchLatestVersion() {
 
 // src/version.ts
 var import_node_fs4 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var cachedVersion;
 function getThreadnoteVersion() {
   if (cachedVersion !== void 0) {
     return cachedVersion;
   }
   try {
-    const packageJsonPath = (0, import_node_path8.join)(__dirname, "..", "package.json");
+    const packageJsonPath = (0, import_node_path9.join)(__dirname, "..", "package.json");
     const parsed = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf8"));
     cachedVersion = typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown";
   } catch {
@@ -10543,7 +10880,7 @@ async function runHooksInstall(config, agent, options) {
 }
 async function runClaudeHooksInstall(options) {
   const path = expandPath(CLAUDE_SETTINGS_PATH);
-  const existingRaw = await exists(path) ? await (0, import_promises7.readFile)(path, "utf8") : "{}";
+  const existingRaw = await exists(path) ? await (0, import_promises8.readFile)(path, "utf8") : "{}";
   const parsed = parseJsonConfigObject(existingRaw) ?? {};
   const next = options.remove ? withoutThreadnoteHooks(parsed) : withThreadnoteHooks(parsed);
   const before = JSON.stringify(parsed);
@@ -10560,11 +10897,11 @@ async function runClaudeHooksInstall(options) {
     console.log("\nRe-run with --apply to actually modify the file.");
     return;
   }
-  await (0, import_promises7.mkdir)((0, import_node_path9.dirname)(path), { recursive: true });
+  await (0, import_promises8.mkdir)((0, import_node_path10.dirname)(path), { recursive: true });
   const serialized = `${JSON.stringify(next, void 0, 2)}
 `;
-  await (0, import_promises7.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
-  await (0, import_promises7.chmod)(path, 384);
+  await (0, import_promises8.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
+  await (0, import_promises8.chmod)(path, 384);
   console.log(`${options.remove ? "Removed" : "Installed"} threadnote-managed Claude hooks.`);
 }
 function withThreadnoteHooks(input2) {
@@ -10642,7 +10979,7 @@ async function hasManagedClaudeHooks() {
   if (!await exists(path)) {
     return false;
   }
-  const raw = await (0, import_promises7.readFile)(path, "utf8");
+  const raw = await (0, import_promises8.readFile)(path, "utf8");
   const parsed = parseJsonConfigObject(raw);
   if (!parsed || !isJsonObject(parsed.hooks)) {
     return false;
@@ -10704,7 +11041,7 @@ async function runSessionStartHook(config, options = {}) {
 async function emitUpdateBannerIfOutdated(config) {
   try {
     const result = await checkForThreadnoteUpdate({
-      cachePath: (0, import_node_path9.join)(config.agentContextHome, ".update-state.json"),
+      cachePath: (0, import_node_path10.join)(config.agentContextHome, ".update-state.json"),
       currentVersion: getThreadnoteVersion()
     });
     if (!result || !result.outdated) {
@@ -10729,13 +11066,13 @@ async function emitUpdateBannerIfOutdated(config) {
 }
 
 // src/seeding.ts
-var import_promises8 = require("node:fs/promises");
-var import_node_path10 = require("node:path");
+var import_promises9 = require("node:fs/promises");
+var import_node_path11 = require("node:path");
 async function runSeed(config, options) {
   const manifest = await readSeedManifest(config.manifestPath);
   const ignorePatterns = await loadIgnorePatterns();
   const ov = await openVikingCliForMode(options.dryRun === true);
-  const statePath = (0, import_node_path10.join)(config.agentContextHome, SEED_STATE_FILE);
+  const statePath = (0, import_node_path11.join)(config.agentContextHome, SEED_STATE_FILE);
   const state = options.force === true ? { files: {}, version: 1 } : await readSeedState(statePath);
   const projects = filterProjects(manifest.projects, options.only);
   let importedCount = 0;
@@ -10760,7 +11097,15 @@ async function runSeed(config, options) {
         skippedCount += 1;
         continue;
       }
-      const args = withIdentity(config, ["add-resource", importPath, "--to", candidate.destinationUri, "--wait"]);
+      const args = withIdentity(config, [
+        "add-resource",
+        importPath,
+        "--to",
+        candidate.destinationUri,
+        "--reason",
+        seedResourceReason(candidate),
+        "--wait"
+      ]);
       await maybeRun(options.dryRun === true, ov, args);
       importedCount += 1;
       if (fileStat && options.dryRun !== true) {
@@ -10790,7 +11135,7 @@ function filterProjects(projects, only) {
 }
 async function statSeedFile(path) {
   try {
-    const result = await (0, import_promises8.stat)(path);
+    const result = await (0, import_promises9.stat)(path);
     return { mtimeMs: result.mtimeMs, size: result.size };
   } catch (_err) {
     return void 0;
@@ -10798,7 +11143,7 @@ async function statSeedFile(path) {
 }
 async function readSeedState(path) {
   try {
-    const raw = await (0, import_promises8.readFile)(path, "utf8");
+    const raw = await (0, import_promises9.readFile)(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !isJsonObject(parsed.files)) {
       return { files: {}, version: 1 };
@@ -10815,13 +11160,13 @@ async function readSeedState(path) {
   }
 }
 async function writeSeedState(path, state) {
-  await ensureDirectory((0, import_node_path10.dirname)(path), false);
-  await (0, import_promises8.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
+  await ensureDirectory((0, import_node_path11.dirname)(path), false);
+  await (0, import_promises9.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function runInitManifest(config, options) {
   const manifestPath = expandPath(
-    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path10.join)(config.agentContextHome, USER_MANIFEST_NAME)
+    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path11.join)(config.agentContextHome, USER_MANIFEST_NAME)
   );
   const repoInputs = options.repo && options.repo.length > 0 ? options.repo : [getInvocationCwd()];
   const existingManifest = options.replace === true || !await exists(manifestPath) ? void 0 : await readSeedManifest(manifestPath);
@@ -10864,9 +11209,9 @@ async function runInitManifest(config, options) {
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path10.dirname)(manifestPath), false);
-  await (0, import_promises8.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises8.chmod)(manifestPath, 384);
+  await ensureDirectory((0, import_node_path11.dirname)(manifestPath), false);
+  await (0, import_promises9.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises9.chmod)(manifestPath, 384);
   console.log(`Wrote manifest: ${manifestPath}`);
   console.log("Seed with:");
   console.log("  threadnote seed --dry-run");
@@ -10874,17 +11219,33 @@ async function runInitManifest(config, options) {
 }
 async function runSeedSkills(config, options) {
   const ov = await openVikingCliForMode(options.dryRun === true);
-  const skills = await collectSkillCandidates(config);
+  const catalogItems = await collectSkillCandidates(config);
   const nativeMode = options.native === true;
   console.log(
     nativeMode ? "Skill seed mode: native OpenViking skills. This requires a working VLM config." : "Skill seed mode: resource catalog. Use --native only after configuring a working VLM provider."
   );
-  for (const skill of skills) {
-    console.log(`Skill ${skill.source}: ${skill.filePath}`);
-    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : ["add-resource", skill.filePath, "--to", skillResourceUri(skill), "--wait"];
+  let skippedCount = 0;
+  for (const skill of catalogItems) {
+    console.log(`${skill.kind === "command" ? "Command" : "Skill"} ${skill.source}: ${skill.filePath}`);
+    if (nativeMode && skill.kind === "command") {
+      skippedCount += 1;
+      console.log(`SKIP command in native skill mode: ${skill.filePath}`);
+      continue;
+    }
+    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : [
+      "add-resource",
+      skill.filePath,
+      "--to",
+      skillResourceUri(skill),
+      "--reason",
+      skillResourceReason(skill),
+      "--wait"
+    ];
     await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
   }
-  console.log(`Skill seed complete: ${skills.length} unique skill(s).`);
+  console.log(
+    `Skill seed complete: ${catalogItems.length - skippedCount} unique catalog item(s)${skippedCount > 0 ? `, ${skippedCount} skipped` : ""}.`
+  );
 }
 async function resolveRepoRoot(repoInput) {
   const inputPath = expandPath(repoInput);
@@ -10896,13 +11257,13 @@ async function resolveRepoRoot(repoInput) {
 async function projectIdentity(path) {
   const expanded = expandPath(path);
   try {
-    return await (0, import_promises8.realpath)(expanded);
+    return await (0, import_promises9.realpath)(expanded);
   } catch (_err) {
     return expanded;
   }
 }
 function projectManifestForRepo(repoRoot, existingProjects) {
-  const baseName = uriSegment((0, import_node_path10.basename)(repoRoot));
+  const baseName = uriSegment((0, import_node_path11.basename)(repoRoot));
   const usedNames = new Set(existingProjects.map((project) => project.name));
   const usedUris = new Set(existingProjects.map((project) => project.uri));
   let name = baseName;
@@ -10924,7 +11285,7 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
   for (const pattern of project.seed) {
     const files = await resolveProjectPattern(projectRoot, pattern);
     for (const filePath of files) {
-      const relativePath = toPosixPath((0, import_node_path10.relative)(projectRoot, filePath));
+      const relativePath = toPosixPath((0, import_node_path11.relative)(projectRoot, filePath));
       if (seen.has(relativePath) || matchesIgnore(relativePath, ignorePatterns)) {
         continue;
       }
@@ -10942,20 +11303,20 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
 async function resolveProjectPattern(projectRoot, pattern) {
   const normalizedPattern = toPosixPath(pattern);
   if (!hasGlob(normalizedPattern)) {
-    const filePath = (0, import_node_path10.join)(projectRoot, normalizedPattern);
+    const filePath = (0, import_node_path11.join)(projectRoot, normalizedPattern);
     return await isFile(filePath) ? [filePath] : [];
   }
   const globBase = getGlobBase(normalizedPattern);
-  const basePath = (0, import_node_path10.join)(projectRoot, globBase);
+  const basePath = (0, import_node_path11.join)(projectRoot, globBase);
   if (!await exists(basePath)) {
     return [];
   }
   const regex = globToRegExp(normalizedPattern);
   const files = await walkFiles(basePath);
-  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path10.relative)(projectRoot, filePath))));
+  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path11.relative)(projectRoot, filePath))));
 }
 async function prepareSeedFile(config, candidate, dryRun) {
-  const content = await (0, import_promises8.readFile)(candidate.filePath, "utf8");
+  const content = await (0, import_promises9.readFile)(candidate.filePath, "utf8");
   const redactedContent = shouldRedactPath(candidate.relativePath) ? redactContent(candidate.relativePath, content) : content;
   const secretMatches = detectSecretMatches(redactedContent);
   if (secretMatches.length > 0) {
@@ -10967,39 +11328,54 @@ async function prepareSeedFile(config, candidate, dryRun) {
   if (redactedContent === content) {
     return candidate.filePath;
   }
-  const redactedPath = (0, import_node_path10.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
+  const redactedPath = (0, import_node_path11.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
   if (dryRun) {
     console.log(`Would write redacted copy: ${redactedPath}`);
     return redactedPath;
   }
-  await ensureDirectory((0, import_node_path10.dirname)(redactedPath), false);
-  await (0, import_promises8.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
-  await (0, import_promises8.chmod)(redactedPath, 384);
+  await ensureDirectory((0, import_node_path11.dirname)(redactedPath), false);
+  await (0, import_promises9.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
+  await (0, import_promises9.chmod)(redactedPath, 384);
   return redactedPath;
 }
+function seedResourceReason(candidate) {
+  return `Project guidance for ${candidate.projectName}: ${candidate.relativePath}`;
+}
+function skillResourceReason(skill) {
+  return `${skill.kind === "command" ? "Agent command" : "Agent skill"} catalog item from ${skill.source}: ${(0, import_node_path11.basename)(
+    skill.filePath
+  )}`;
+}
 async function collectSkillCandidates(config) {
   const sources = [
-    { pattern: "~/.codex/skills/**/SKILL.md", source: "codex-global" },
-    { pattern: "~/.codex/plugins/cache/**/skills/**/SKILL.md", source: "codex-plugin-cache" },
-    { pattern: "~/.claude/skills/**/SKILL.md", source: "claude-global" }
+    { kind: "skill", pattern: "~/.codex/skills/**/SKILL.md", source: "codex-global" },
+    { kind: "skill", pattern: "~/.codex/plugins/cache/**/skills/**/SKILL.md", source: "codex-plugin-cache" },
+    { kind: "skill", pattern: "~/.claude/skills/**/SKILL.md", source: "claude-global" },
+    { kind: "command", pattern: "~/.claude/commands/**/*.md", source: "claude-commands-global" }
   ];
   try {
     const manifest = await readSeedManifest(config.manifestPath);
     for (const project of manifest.projects) {
       sources.push({
+        kind: "skill",
         pattern: `${project.path}/.claude/skills/**/SKILL.md`,
         source: `repo-local:${project.name}`
       });
+      sources.push({
+        kind: "command",
+        pattern: `${project.path}/.claude/commands/**/*.md`,
+        source: `repo-local:${project.name}:claude-commands`
+      });
     }
   } catch (err) {
-    console.log(`WARN cannot read manifest for repo-local skill discovery: ${errorMessage(err)}`);
+    console.log(`WARN cannot read manifest for repo-local skill/command discovery: ${errorMessage(err)}`);
   }
   const seenHashes = /* @__PURE__ */ new Set();
   const skills = [];
   for (const source of sources) {
     const files = await resolveAbsolutePattern(expandPath(source.pattern));
     for (const filePath of files) {
-      const content = await (0, import_promises8.readFile)(filePath, "utf8");
+      const content = await (0, import_promises9.readFile)(filePath, "utf8");
       const matches = detectSecretMatches(content);
       if (matches.length > 0) {
         console.log(`SKIP skill with possible secret: ${filePath}`);
@@ -11010,7 +11386,7 @@ async function collectSkillCandidates(config) {
         continue;
       }
       seenHashes.add(hash);
-      skills.push({ filePath, hash, source: source.source });
+      skills.push({ filePath, hash, kind: source.kind, source: source.source });
     }
   }
   return skills;
@@ -11030,10 +11406,19 @@ async function resolveAbsolutePattern(pattern) {
   return files.filter((filePath) => regex.test(toPosixPath(filePath)));
 }
 function skillResourceUri(skill) {
-  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${uriSegment((0, import_node_path10.basename)((0, import_node_path10.dirname)(skill.filePath)))}-${skill.hash.slice(0, 12)}.md`;
+  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${skillResourceName(skill)}-${skill.hash.slice(0, 12)}.md`;
+}
+function skillResourceName(skill) {
+  const fileName = (0, import_node_path11.basename)(skill.filePath);
+  if (fileName.toLowerCase() === "skill.md") {
+    return uriSegment((0, import_node_path11.basename)((0, import_node_path11.dirname)(skill.filePath)));
+  }
+  const extensionIndex = fileName.lastIndexOf(".");
+  const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName;
+  return uriSegment(stem);
 }
 async function loadIgnorePatterns() {
-  const raw = await (0, import_promises8.readFile)((0, import_node_path10.join)(toolRoot(), ".threadnoteignore"), "utf8");
+  const raw = await (0, import_promises9.readFile)((0, import_node_path11.join)(toolRoot(), ".threadnoteignore"), "utf8");
   return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function matchesIgnore(relativePath, patterns) {
@@ -11106,18 +11491,18 @@ function detectSecretMatches(content) {
 // src/lifecycle.ts
 var import_node_child_process3 = require("node:child_process");
 var import_node_fs6 = require("node:fs");
-var import_promises11 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var import_node_os6 = require("node:os");
-var import_node_path12 = require("node:path");
+var import_node_path13 = require("node:path");
 var import_node_process3 = require("node:process");
-var import_promises12 = require("node:readline/promises");
+var import_promises13 = require("node:readline/promises");
 
 // src/update.ts
 var import_node_fs5 = require("node:fs");
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
-var import_node_path11 = require("node:path");
-var import_promises10 = require("node:readline/promises");
+var import_node_path12 = require("node:path");
+var import_promises11 = require("node:readline/promises");
 var import_node_process2 = require("node:process");
 
 // src/release_notes.ts
@@ -11286,7 +11671,9 @@ async function runUpdate(config, options) {
     return;
   }
   const threadnoteCommand = await installedThreadnoteCommand(runtime);
-  await maybeRun(options.dryRun === true, threadnoteCommand, ["repair", "--no-post-update"]);
+  console.log("");
+  console.log("Repairing local Threadnote setup after package update.");
+  await runThreadnoteSubcommand(options.dryRun === true, threadnoteCommand, ["repair", "--no-post-update"]);
   if (options.postUpdate !== false) {
     const postUpdateArgs = [
       "post-update",
@@ -11296,15 +11683,7 @@ async function runUpdate(config, options) {
       info2.latestVersion,
       ...options.yes === true ? ["--yes"] : []
     ];
-    if (options.dryRun === true) {
-      await maybeRun(true, threadnoteCommand, postUpdateArgs);
-    } else {
-      console.log(`Running: ${formatShellCommand(threadnoteCommand, postUpdateArgs)}`);
-      const postUpdateExitCode = await runInteractive(threadnoteCommand, postUpdateArgs);
-      if (postUpdateExitCode !== 0) {
-        throw new Error(`${formatShellCommand(threadnoteCommand, postUpdateArgs)} exited with ${postUpdateExitCode}.`);
-      }
-    }
+    await runThreadnoteSubcommand(options.dryRun === true, threadnoteCommand, postUpdateArgs);
   } else {
     console.log("Skipping post-update migration prompts because --no-post-update was provided.");
   }
@@ -11388,7 +11767,7 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
   }
   console.log("");
   console.log(`Upgrading OpenViking ${installedVersion} -> ${pinned} (pinned by Threadnote).`);
-  console.log("Picks up upstream fixes for share-sync reliability (reindex lock acquisition, ov wait timeout).");
+  console.log("Picks up upstream CLI, resource-ingestion, and index reliability fixes.");
   const wasRunning = await isOpenVikingHealthy(config);
   const usingLaunchd = await isLaunchAgentInstalled();
   const threadnoteCommand = currentThreadnoteCommand() ?? await findExecutable([NPM_PACKAGE_NAME]) ?? NPM_PACKAGE_NAME;
@@ -11406,9 +11785,11 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
   if (usingLaunchd) {
     const launchAgentPath = launchAgentPlistPath();
     await runCommand("launchctl", ["unload", launchAgentPath], { allowFailure: true });
+    await waitForOpenVikingPortClosed(config, 15e3);
     await runCommand("launchctl", ["load", launchAgentPath], { allowFailure: true });
   } else {
     await maybeRun(false, threadnoteCommand, ["stop"]);
+    await waitForOpenVikingPortClosed(config, 15e3);
     await maybeRun(false, threadnoteCommand, ["start"]);
   }
   const healthyAfter = await waitForOpenVikingHealthy(config, 1e4);
@@ -11419,6 +11800,17 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
     console.log("Check the server log or run: threadnote start");
   }
 }
+async function runThreadnoteSubcommand(dryRun, executable, args) {
+  if (dryRun) {
+    await maybeRun(true, executable, args);
+    return;
+  }
+  console.log(`Running: ${formatShellCommand(executable, args)}`);
+  const exitCode = await runInteractive(executable, args);
+  if (exitCode !== 0) {
+    throw new Error(`${formatShellCommand(executable, args)} exited with ${exitCode}.`);
+  }
+}
 function openVikingHealthEndpoint(config) {
   return `http://${config.host}:${config.port}/health`;
 }
@@ -11442,21 +11834,36 @@ async function waitForOpenVikingHealthy(config, timeoutMs) {
     if (await isOpenVikingHealthy(config)) {
       return true;
     }
-    await new Promise((resolvePromise) => {
-      setTimeout(resolvePromise, 500);
-    });
+    await sleep(500);
   }
   return isOpenVikingHealthy(config);
 }
+async function waitForOpenVikingPortClosed(config, timeoutMs) {
+  console.log(`Waiting for OpenViking port ${config.host}:${config.port} to close before restart.`);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!await isTcpPortOpen(config.host, config.port, 300)) {
+      return true;
+    }
+    await sleep(300);
+  }
+  if (!await isTcpPortOpen(config.host, config.port, 300)) {
+    return true;
+  }
+  console.log(
+    `Warning: OpenViking port ${config.host}:${config.port} is still in use after ${timeoutMs / 1e3}s; start may fail.`
+  );
+  return false;
+}
 function launchAgentPlistPath() {
-  return (0, import_node_path11.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
+  return (0, import_node_path12.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
 }
 async function isLaunchAgentInstalled() {
   if (process.platform !== "darwin") {
     return false;
   }
   try {
-    await (0, import_promises9.access)(launchAgentPlistPath(), import_node_fs5.constants.F_OK);
+    await (0, import_promises10.access)(launchAgentPlistPath(), import_node_fs5.constants.F_OK);
     return true;
   } catch (_err) {
     return false;
@@ -11485,7 +11892,7 @@ async function getUpdateInfo(config, options) {
   };
 }
 async function currentPackageVersion() {
-  const rawPackage = await (0, import_promises9.readFile)((0, import_node_path11.join)(toolRoot(), "package.json"), "utf8");
+  const rawPackage = await (0, import_promises10.readFile)((0, import_node_path12.join)(toolRoot(), "package.json"), "utf8");
   const parsed = JSON.parse(rawPackage);
   if (!isJsonObject(parsed) || typeof parsed.version !== "string") {
     throw new Error("Could not read current threadnote package version.");
@@ -11535,11 +11942,11 @@ async function readFreshCache(config, registry) {
 }
 async function writeUpdateCache2(config, cache) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises9.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises10.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function updateCachePath(config) {
-  return (0, import_node_path11.join)(config.agentContextHome, "update-check.json");
+  return (0, import_node_path12.join)(config.agentContextHome, "update-check.json");
 }
 async function runApplicablePostUpdateMigrations(config, options) {
   const state = await readPostUpdateState(config);
@@ -11603,7 +12010,7 @@ async function applicablePostUpdateMigrations(config, options) {
   return applicable;
 }
 async function readPostUpdateMigrations() {
-  const raw = await readFileIfExists((0, import_node_path11.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
+  const raw = await readFileIfExists((0, import_node_path12.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
   if (!raw) {
     return [];
   }
@@ -11642,7 +12049,7 @@ function printPostUpdateMigration(migration) {
   }
 }
 async function confirmPostUpdateMigration(prompt, defaultYes = false) {
-  const readline = (0, import_promises10.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+  const readline = (0, import_promises11.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
   try {
     const answer = (await readline.question(prompt)).trim().toLowerCase();
     if (answer === "") {
@@ -11677,11 +12084,11 @@ async function readPostUpdateState(config) {
 }
 async function writePostUpdateState(config, state) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises9.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
+  await (0, import_promises10.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function postUpdateStatePath(config) {
-  return (0, import_node_path11.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
+  return (0, import_node_path12.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
 }
 async function resolveUpdateRuntime(runtime) {
   if (runtime !== "auto") {
@@ -11711,14 +12118,14 @@ async function runtimeThreadnoteBin(runtime) {
   if (runtime === "npm") {
     const result = await runCommand("npm", ["prefix", "--global"], { allowFailure: true });
     const prefix = result.stdout.trim();
-    return prefix ? (0, import_node_path11.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
+    return prefix ? (0, import_node_path12.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
   }
   if (runtime === "bun") {
     const result = await runCommand("bun", ["pm", "bin", "-g"], { allowFailure: true });
     const binDir = result.stdout.trim();
-    return binDir ? (0, import_node_path11.join)(binDir, NPM_PACKAGE_NAME) : void 0;
+    return binDir ? (0, import_node_path12.join)(binDir, NPM_PACKAGE_NAME) : void 0;
   }
-  return (0, import_node_path11.join)(process.env.DENO_INSTALL ?? (0, import_node_path11.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
+  return (0, import_node_path12.join)(process.env.DENO_INSTALL ?? (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
 }
 function updatePackageCommand(runtime, registry) {
   if (runtime === "npm") {
@@ -11786,9 +12193,10 @@ async function collectDoctorChecks(config, options = {}) {
   checks.push(await commandShimCheck());
   checks.push(...await userAgentInstructionsChecks());
   checks.push(await manifestCheck(config.manifestPath));
-  checks.push(await fileCheck((0, import_node_path12.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
-  checks.push(await fileCheck((0, import_node_path12.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
-  checks.push(await fileCheck((0, import_node_path12.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
+  checks.push(await recallIndexFreshnessCheck(config));
+  checks.push(await fileCheck((0, import_node_path13.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
+  checks.push(await fileCheck((0, import_node_path13.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
+  checks.push(await fileCheck((0, import_node_path13.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
   checks.push(await healthCheck(config));
   return checks;
 }
@@ -11796,9 +12204,9 @@ async function runInstall(config, options) {
   const repairInvalidConfigs = options.repairInvalidConfigs === true;
   const dryRun = options.dryRun === true;
   await ensureDirectory(config.agentContextHome, dryRun);
-  await ensureDirectory((0, import_node_path12.join)(config.agentContextHome, "logs"), dryRun);
-  await ensureDirectory((0, import_node_path12.join)(config.agentContextHome, "redacted"), dryRun);
-  await ensureDirectory((0, import_node_path12.join)(config.agentContextHome, "mcp"), dryRun);
+  await ensureDirectory((0, import_node_path13.join)(config.agentContextHome, "logs"), dryRun);
+  await ensureDirectory((0, import_node_path13.join)(config.agentContextHome, "redacted"), dryRun);
+  await ensureDirectory((0, import_node_path13.join)(config.agentContextHome, "mcp"), dryRun);
   await installCommandShim(dryRun);
   await installUserAgentInstructions(dryRun);
   const serverPath = await findOpenVikingServer();
@@ -11835,18 +12243,19 @@ async function runInstall(config, options) {
   }
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path12.join)(config.agentContextHome, "ov.conf"),
+    destinationPath: (0, import_node_path13.join)(config.agentContextHome, "ov.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairOpenVikingConfig(content, config) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path12.join)(toolRoot(), "config", "ov.conf.template.json")
+    templatePath: (0, import_node_path13.join)(toolRoot(), "config", "ov.conf.template.json")
   });
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path12.join)(config.agentContextHome, "ovcli.conf"),
+    destinationPath: (0, import_node_path13.join)(config.agentContextHome, "ovcli.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairLegacyOvCliConfig(content) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path12.join)(toolRoot(), "config", "ovcli.conf.template.json")
+    templatePath: (0, import_node_path13.join)(toolRoot(), "config", "ovcli.conf.template.json")
   });
+  await configureOpenVikingCliLanguage(config, dryRun);
   if (options.start !== false) {
     const healthy = await repairServerHealth(config, dryRun);
     if (!healthy && !dryRun) {
@@ -11873,6 +12282,7 @@ async function runRepair(config, options) {
   } else {
     console.log("Skipping server health repair because --no-start was provided.");
   }
+  await repairRecallIndex(config, dryRun);
   const mcpClients = await resolveMcpClients(options.mcp ?? "available", "repair");
   if (mcpClients.length === 0) {
     console.log("Skipping MCP config repair.");
@@ -11899,7 +12309,7 @@ async function runUninstall(config, options) {
   }
   console.log("Uninstalling local Threadnote setup.");
   await runStop(config, { dryRun });
-  await removePathIfExists((0, import_node_path12.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
+  await removePathIfExists((0, import_node_path13.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
   await removeLaunchAgent(dryRun);
   await removeMcpConfigs(options.mcp ?? "available", dryRun);
   await removeMcpSnippets(config, dryRun);
@@ -11956,25 +12366,102 @@ async function repairManifest(config, dryRun) {
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path12.dirname)(config.manifestPath), false);
+  await ensureDirectory((0, import_node_path13.dirname)(config.manifestPath), false);
   const currentContent = await readFileIfExists(config.manifestPath);
   if (currentContent !== void 0) {
     const backupPath = `${config.manifestPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises11.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises11.chmod)(backupPath, 384);
+    await (0, import_promises12.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises12.chmod)(backupPath, 384);
     console.log(`Backup: ${backupPath}`);
   }
-  await (0, import_promises11.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises11.chmod)(config.manifestPath, 384);
+  await (0, import_promises12.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises12.chmod)(config.manifestPath, 384);
   console.log(`Wrote replacement manifest: ${config.manifestPath}`);
 }
+async function repairRecallIndex(config, dryRun) {
+  console.log("\nRepairing recall index freshness.");
+  const ov = dryRun ? await findExecutable(["ov", "openviking"]) ?? "ov" : await findExecutable(["ov", "openviking"]);
+  if (!ov) {
+    console.log("Skipping recall index repair: neither ov nor openviking was found in PATH.");
+    return;
+  }
+  const progress = startProgress("Scanning recall index freshness across memories and seeded resources.");
+  try {
+    const result = await repairStaleRecallIndex(config, ov, {
+      collapseDepth: MAINTENANCE_COLLAPSE_DEPTH,
+      collapseToRoots: true,
+      dryRun,
+      ignoreBackoff: true,
+      includeAgentSkills: true,
+      includeManifestResources: true,
+      maxTargets: MAINTENANCE_MAX_REPAIR_TARGETS,
+      onRepairFailure: async () => {
+        progress.update("A recall index reindex failed; checking OpenViking health before continuing.");
+        await repairServerHealth(config, dryRun);
+      },
+      onProgress: (event) => {
+        if (event.type === "scan-complete") {
+          if (event.totalTargets === 0) {
+            progress.update("No stale recall index scopes found.");
+          } else {
+            progress.update(
+              `Found ${event.totalTargets} stale recall index scope(s); repairing ${event.repairTargetCount}.`
+            );
+          }
+        } else if (event.type === "repair-start") {
+          progress.update(
+            `Reindexing ${event.index}/${event.total}: ${event.target.uri} (${event.target.staleCount} stale summaries).`
+          );
+        } else if (event.type === "repair-dry-run") {
+          progress.update(
+            `Planning reindex ${event.index}/${event.total}: ${event.target.uri} (${event.target.staleCount} stale summaries).`
+          );
+        } else if (event.type === "repair-skip-recent") {
+          progress.update(`Skipping recently repaired scope ${event.index}/${event.total}: ${event.target.uri}.`);
+        }
+      }
+    });
+    progress.stop();
+    const messages = formatRecallIndexRepairMessages(result, { dryRun, maxUris: 20 });
+    if (messages.length === 0) {
+      console.log("Recall index freshness OK.");
+      return;
+    }
+    for (const message of messages) {
+      console.log(message);
+    }
+  } catch (err) {
+    progress.stop();
+    console.log(`WARN could not repair recall index freshness: ${errorMessage(err)}`);
+  }
+}
+async function configureOpenVikingCliLanguage(config, dryRun) {
+  const ov = dryRun ? await findExecutable(["ov", "openviking"]) ?? "ov" : await findExecutable(["ov", "openviking"]);
+  if (!ov) {
+    return;
+  }
+  const installedVersion = dryRun ? void 0 : await readOpenVikingCliVersion2(ov);
+  const effectiveVersion = installedVersion ?? config.openVikingVersion;
+  if (compareVersions(effectiveVersion, "0.3.23") < 0) {
+    return;
+  }
+  await maybeRun(dryRun, ov, ["language", "en"], { allowFailure: true });
+}
+async function readOpenVikingCliVersion2(ov) {
+  const result = await runCommand(ov, ["version"], { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  const match = result.stdout.match(/^\s*CLI:\s*(\S+)/m);
+  return match ? match[1] : void 0;
+}
 async function findOpenVikingServer() {
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
   if (onPath) {
     return onPath;
   }
   for (const candidateDir of await openVikingServerCandidateDirs()) {
-    const candidate = (0, import_node_path12.join)(candidateDir, OPENVIKING_SERVER_COMMAND);
+    const candidate = (0, import_node_path13.join)(candidateDir, OPENVIKING_SERVER_COMMAND);
     if (await isExecutable(candidate)) {
       return candidate;
     }
@@ -12020,7 +12507,7 @@ async function maybePrintOpenVikingPathHint(serverPath) {
   if (onPath) {
     return;
   }
-  const binDir = (0, import_node_path12.dirname)(serverPath);
+  const binDir = (0, import_node_path13.dirname)(serverPath);
   const rcHint = suggestedShellRc(process.env.SHELL, (0, import_node_os6.platform)());
   console.log(
     `Note: ${serverPath} is installed but ${binDir} is not on this shell's PATH. Add \`export PATH="${binDir}:$PATH"\` to ${rcHint} so other tools can find openviking-server.`
@@ -12064,7 +12551,7 @@ async function runStart(config, options) {
     );
   }
   const logPath = openVikingLogPath(config);
-  await ensureDirectory((0, import_node_path12.dirname)(logPath), false);
+  await ensureDirectory((0, import_node_path13.dirname)(logPath), false);
   if (options.foreground === true) {
     const result = await runInteractive(server, args);
     process.exitCode = result;
@@ -12073,7 +12560,7 @@ async function runStart(config, options) {
   const logFd = (0, import_node_fs6.openSync)(logPath, "a");
   const child = spawnDetachedServerWithLog(server, args, logFd);
   child.unref();
-  await (0, import_promises11.writeFile)((0, import_node_path12.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
+  await (0, import_promises12.writeFile)((0, import_node_path13.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
 `, "utf8");
   const health = await waitForOpenVikingHealth(config, START_HEALTH_TIMEOUT_MS);
   if (health) {
@@ -12106,7 +12593,7 @@ async function runStop(config, options) {
       console.log(`No LaunchAgent found: ${launchAgentPath}`);
     }
   }
-  const pidPath = (0, import_node_path12.join)(config.agentContextHome, "openviking-server.pid");
+  const pidPath = (0, import_node_path13.join)(config.agentContextHome, "openviking-server.pid");
   const pidText = await readFileIfExists(pidPath);
   if (!pidText) {
     console.log("No pid file found for detached OpenViking server.");
@@ -12148,7 +12635,7 @@ async function openVikingServerCheck() {
   }
   const result = await runCommand(executable, ["--help"], { allowFailure: true });
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
-  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path12.dirname)(executable)} to PATH)`;
+  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path13.dirname)(executable)} to PATH)`;
   return {
     name,
     status: result.exitCode === 0 ? "ok" : "warn",
@@ -12217,7 +12704,7 @@ async function pythonSystemCertificatesCheck() {
   };
 }
 async function commandShimCheck() {
-  const shimPath = (0, import_node_path12.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path13.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     return { name: "threadnote shim", status: "warn", detail: `${shimPath} missing; repair will create it` };
@@ -12283,11 +12770,11 @@ async function hasPythonModule(serverPath, moduleName) {
 async function siblingPythonForExecutable(executablePath) {
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises11.realpath)(executablePath);
+    resolvedPath = await (0, import_promises12.realpath)(executablePath);
   } catch (_err) {
     return void 0;
   }
-  const pythonPath = (0, import_node_path12.join)((0, import_node_path12.dirname)(resolvedPath), "python");
+  const pythonPath = (0, import_node_path13.join)((0, import_node_path13.dirname)(resolvedPath), "python");
   return await exists(pythonPath) ? pythonPath : void 0;
 }
 async function manifestCheck(path) {
@@ -12298,6 +12785,29 @@ async function manifestCheck(path) {
     return { name: "manifest", status: "fail", detail: errorMessage(err) };
   }
 }
+async function recallIndexFreshnessCheck(config) {
+  try {
+    const targets = await findStaleRecallIndexTargets(config, {
+      collapseToRoots: true,
+      includeAgentSkills: true,
+      includeManifestResources: true
+    });
+    if (targets.length === 0) {
+      return { name: "recall index freshness", status: "ok", detail: "no stale generated summaries found" };
+    }
+    const staleSummaryCount = targets.reduce((total, target) => total + target.staleCount, 0);
+    const sampleUris = targets.slice(0, 3).map((target) => target.uri);
+    const extraCount = targets.length - sampleUris.length;
+    const sample = `${sampleUris.join(", ")}${extraCount > 0 ? `, +${extraCount} more` : ""}`;
+    return {
+      name: "recall index freshness",
+      status: "warn",
+      detail: `${staleSummaryCount} stale generated summary file(s) under ${targets.length} scope(s); run repair to reindex ${sample}`
+    };
+  } catch (err) {
+    return { name: "recall index freshness", status: "warn", detail: errorMessage(err) };
+  }
+}
 async function fileCheck(path, label) {
   return await exists(path) ? { name: label, status: "ok", detail: path } : { name: label, status: "fail", detail: `${path} missing` };
 }
@@ -12358,7 +12868,7 @@ async function offerToInstallUv() {
     );
     return false;
   }
-  const readline = (0, import_promises12.createInterface)({ input: import_node_process3.stdin, output: import_node_process3.stdout });
+  const readline = (0, import_promises13.createInterface)({ input: import_node_process3.stdin, output: import_node_process3.stdout });
   let answer;
   try {
     answer = (await readline.question(
@@ -12483,38 +12993,38 @@ function printInstallNextSteps(options) {
 }
 async function writeTemplateIfMissing(options) {
   if (await exists(options.destinationPath)) {
-    const currentContent = await (0, import_promises11.readFile)(options.destinationPath, "utf8");
+    const currentContent = await (0, import_promises12.readFile)(options.destinationPath, "utf8");
     if (options.shouldRepair?.(currentContent) !== true) {
       console.log(`Already exists: ${options.destinationPath}`);
       return;
     }
-    const rendered2 = renderTemplate(await (0, import_promises11.readFile)(options.templatePath, "utf8"), options.config);
+    const rendered2 = renderTemplate(await (0, import_promises12.readFile)(options.templatePath, "utf8"), options.config);
     if (options.dryRun) {
       console.log(`Would repair generated config: ${options.destinationPath}`);
       return;
     }
     const backupPath = `${options.destinationPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises11.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises11.chmod)(backupPath, 384);
-    await (0, import_promises11.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
-    await (0, import_promises11.chmod)(options.destinationPath, 384);
+    await (0, import_promises12.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises12.chmod)(backupPath, 384);
+    await (0, import_promises12.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
+    await (0, import_promises12.chmod)(options.destinationPath, 384);
     console.log(`Repaired generated config: ${options.destinationPath}`);
     console.log(`Backup: ${backupPath}`);
     return;
   }
-  const rendered = renderTemplate(await (0, import_promises11.readFile)(options.templatePath, "utf8"), options.config);
+  const rendered = renderTemplate(await (0, import_promises12.readFile)(options.templatePath, "utf8"), options.config);
   if (options.dryRun) {
     console.log(`Would write ${options.destinationPath}`);
     return;
   }
-  await ensureDirectory((0, import_node_path12.dirname)(options.destinationPath), false);
-  await (0, import_promises11.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
-  await (0, import_promises11.chmod)(options.destinationPath, 384);
+  await ensureDirectory((0, import_node_path13.dirname)(options.destinationPath), false);
+  await (0, import_promises12.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
+  await (0, import_promises12.chmod)(options.destinationPath, 384);
   console.log(`Wrote ${options.destinationPath}`);
 }
 async function installCommandShim(dryRun) {
   const binDir = expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin");
-  const shimPath = (0, import_node_path12.join)(binDir, "threadnote");
+  const shimPath = (0, import_node_path13.join)(binDir, "threadnote");
   const existingContent = await readFileIfExists(shimPath);
   if (existingContent && !isManagedCommandShim(existingContent)) {
     console.log(`WARN not overwriting existing command shim: ${shimPath}`);
@@ -12530,12 +13040,12 @@ async function installCommandShim(dryRun) {
     return;
   }
   await ensureDirectory(binDir, false);
-  await (0, import_promises11.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
-  await (0, import_promises11.chmod)(shimPath, 493);
+  await (0, import_promises12.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
+  await (0, import_promises12.chmod)(shimPath, 493);
   console.log(`Wrote command shim: ${shimPath}`);
 }
 async function removeCommandShim(dryRun) {
-  const shimPath = (0, import_node_path12.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path13.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     console.log(`Already absent: ${shimPath}`);
@@ -12569,8 +13079,8 @@ async function installUserAgentInstructions(dryRun) {
       console.log(currentContent === void 0 ? `Would write ${targetPath}` : `Would update ${targetPath}`);
       continue;
     }
-    await ensureDirectory((0, import_node_path12.dirname)(targetPath), false);
-    await (0, import_promises11.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await ensureDirectory((0, import_node_path13.dirname)(targetPath), false);
+    await (0, import_promises12.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(currentContent === void 0 ? `Wrote ${targetPath}` : `Updated ${targetPath}`);
   }
 }
@@ -12607,7 +13117,7 @@ async function removeUserAgentInstructions(dryRun) {
       console.log(`Would update ${targetPath}`);
       continue;
     }
-    await (0, import_promises11.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await (0, import_promises12.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(`Updated ${targetPath}`);
   }
 }
@@ -12627,7 +13137,7 @@ async function renderUserAgentInstructions(target) {
   ].join("\n");
 }
 async function renderUserAgentInstructionsBlock() {
-  const instructions = (await (0, import_promises11.readFile)((0, import_node_path12.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
+  const instructions = (await (0, import_promises12.readFile)((0, import_node_path13.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
   return `${USER_INSTRUCTIONS_START_MARKER}
 ${instructions}
 ${USER_INSTRUCTIONS_END_MARKER}`;
@@ -12711,9 +13221,9 @@ async function installLaunchAgent(config, dryRun) {
       `Cannot install LaunchAgent: ${OPENVIKING_SERVER_COMMAND} was not found in PATH, uv tool bin dir, $UV_TOOL_BIN_DIR, or ~/.local/bin. Run \`threadnote install\` first.`
     );
   }
-  const source = (0, import_node_path12.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
+  const source = (0, import_node_path13.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
   const destination = expandPath(`~/Library/LaunchAgents/${LAUNCHD_LABEL}.plist`);
-  const rendered = renderTemplate(await (0, import_promises11.readFile)(source, "utf8"), config, {
+  const rendered = renderTemplate(await (0, import_promises12.readFile)(source, "utf8"), config, {
     OPENVIKING_SERVER_PATH: resolvedServer ?? OPENVIKING_SERVER_COMMAND
   });
   if (dryRun) {
@@ -12725,9 +13235,9 @@ async function installLaunchAgent(config, dryRun) {
     console.log(`Would run: launchctl start ${LAUNCHD_LABEL}`);
     return;
   }
-  await ensureDirectory((0, import_node_path12.dirname)(destination), false);
-  await ensureDirectory((0, import_node_path12.dirname)(openVikingLogPath(config)), false);
-  await (0, import_promises11.writeFile)(destination, rendered, "utf8");
+  await ensureDirectory((0, import_node_path13.dirname)(destination), false);
+  await ensureDirectory((0, import_node_path13.dirname)(openVikingLogPath(config)), false);
+  await (0, import_promises12.writeFile)(destination, rendered, "utf8");
   await maybeRun(false, "launchctl", ["unload", destination], { allowFailure: true });
   await maybeRun(false, "launchctl", ["load", destination]);
   await maybeRun(false, "launchctl", ["start", LAUNCHD_LABEL]);
@@ -12790,7 +13300,7 @@ function isGeneratedLocalPilotConfig(parsed, config) {
   if (typeof parsed.default_user !== "string") {
     return false;
   }
-  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path12.join)(config.agentContextHome, "data")) {
+  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path13.join)(config.agentContextHome, "data")) {
     return false;
   }
   return isJsonObject(parsed.server) && parsed.server.host === config.host && String(parsed.server.port) === String(config.port);
@@ -12852,9 +13362,9 @@ function printWhatsNew(whatsNew) {
 // src/manager.ts
 var import_node_http2 = require("node:http");
 var import_node_crypto2 = require("node:crypto");
-var import_promises13 = require("node:fs/promises");
+var import_promises14 = require("node:fs/promises");
 var import_node_os7 = require("node:os");
-var import_node_path13 = require("node:path");
+var import_node_path14 = require("node:path");
 var STATIC_FILES = {
   "/": { contentType: "text/html; charset=utf-8", path: "index.html" },
   "/index.html": { contentType: "text/html; charset=utf-8", path: "index.html" },
@@ -12897,24 +13407,46 @@ async function memoryTree(config) {
   const root = localMemoriesRoot(config);
   return readTree(config, root, `viking://user/${uriSegment(config.user)}/memories`, "");
 }
+async function resourcesTree(config) {
+  const root = localResourcesRoot(config);
+  try {
+    return await readTree(config, root, "viking://resources", "", {
+      parseMemoryDocuments: false,
+      rootName: "resources"
+    });
+  } catch (err) {
+    if (isMissingPathError(err)) {
+      return {
+        children: [],
+        isDir: true,
+        isShared: false,
+        isSystem: false,
+        name: "resources",
+        relativePath: "",
+        uri: "viking://resources"
+      };
+    }
+    throw err;
+  }
+}
 async function readManagedMemory(config, uri) {
   assertVikingUri(uri);
   const path = localPathForMemoryUri(config, uri);
   if (!path) {
     throw new Error(`Manager can only read current-user memory URIs: ${uri}`);
   }
-  const [content, pathStat] = await Promise.all([(0, import_promises13.readFile)(path, "utf8"), (0, import_promises13.stat)(path)]);
-  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path).split(import_node_path13.sep).join("/");
+  const [content, pathStat] = await Promise.all([(0, import_promises14.readFile)(path, "utf8"), (0, import_promises14.stat)(path)]);
+  const relativePath = (0, import_node_path14.relative)(localMemoriesRoot(config), path).split(import_node_path14.sep).join("/");
   const record = parseMemoryDocument(uri, content);
   return {
     content,
     node: {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
-      isSystem: isSystemMemoryName(path.split(import_node_path13.sep).at(-1) ?? ""),
+      isSystem: isSystemMemoryName(path.split(import_node_path14.sep).at(-1) ?? ""),
       metadata: record?.metadata,
       modTime: pathStat.mtime.toISOString(),
-      name: path.split(import_node_path13.sep).at(-1) ?? uri,
+      name: path.split(import_node_path14.sep).at(-1) ?? uri,
       relativePath,
       sharedTeam: sharedTeamNameForUri(config, uri),
       size: pathStat.size,
@@ -12981,7 +13513,8 @@ async function handleRequest(context, request, response) {
     return;
   }
   if (request.method === "GET" && url.pathname === "/api/tree") {
-    writeJson(response, 200, { tree: await memoryTree(context.config) });
+    const [tree, resourceTree] = await Promise.all([memoryTree(context.config), resourcesTree(context.config)]);
+    writeJson(response, 200, { resourcesTree: resourceTree, tree });
     return;
   }
   if (request.method === "GET" && url.pathname === "/api/memory") {
@@ -13200,21 +13733,20 @@ async function handleRequest(context, request, response) {
 }
 async function serveStatic(context, url, response) {
   const file = STATIC_FILES[url.pathname] ?? STATIC_FILES["/"];
-  const content = await (0, import_promises13.readFile)((0, import_node_path13.join)(toolRoot(), file.root ?? "manager", file.path));
+  const content = await (0, import_promises14.readFile)((0, import_node_path14.join)(toolRoot(), file.root ?? "manager", file.path));
   const headers = { "content-type": file.contentType };
-  if (url.pathname === "/" || url.pathname === "/index.html") {
+  if (file.root !== "docs") {
     headers["cache-control"] = "no-store";
   }
   response.writeHead(200, headers);
   response.end(content);
 }
-async function readTree(config, path, uri, relativePath) {
-  const pathStat = await (0, import_promises13.stat)(path);
-  const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : "memories";
+async function readTree(config, path, uri, relativePath, options = {}) {
+  const pathStat = await (0, import_promises14.stat)(path);
+  const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : options.rootName ?? "memories";
   const isDir = pathStat.isDirectory();
   if (!isDir) {
-    const content = await (0, import_promises13.readFile)(path, "utf8").catch(() => "");
-    const record = parseMemoryDocument(uri, content);
+    const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises14.readFile)(path, "utf8").catch(() => ""));
     return {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
@@ -13228,13 +13760,13 @@ async function readTree(config, path, uri, relativePath) {
       uri
     };
   }
-  const entries = await (0, import_promises13.readdir)(path, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(path, { withFileTypes: true });
   const children = await Promise.all(
     entries.sort(
       (left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name)
     ).map((entry) => {
       const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-      return readTree(config, (0, import_node_path13.join)(path, entry.name), `${uri}/${entry.name}`, childRelative);
+      return readTree(config, (0, import_node_path14.join)(path, entry.name), `${uri}/${entry.name}`, childRelative, options);
     })
   );
   return {
@@ -13408,27 +13940,27 @@ async function removeManagedFolder(config, uri) {
   if (!path) {
     throw new Error(`Manager can only remove current-user memory folders: ${uri}`);
   }
-  const pathStat = await (0, import_promises13.stat)(path);
+  const pathStat = await (0, import_promises14.stat)(path);
   if (!pathStat.isDirectory()) {
     throw new Error(`Not a folder: ${uri}`);
   }
-  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path13.sep).includes("..")) {
+  const relativePath = (0, import_node_path14.relative)(localMemoriesRoot(config), path);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path14.sep).includes("..")) {
     throw new Error("Refusing to remove a folder outside the memories tree.");
   }
   const fileUris = await fileUrisUnderFolder(config, path);
   for (const fileUri of fileUris) {
     await runForget(config, fileUri, {});
   }
-  await (0, import_promises13.rm)(path, { force: true, recursive: true });
+  await (0, import_promises14.rm)(path, { force: true, recursive: true });
   console.log(`Removed folder: ${uri}`);
   console.log(`Forgot ${fileUris.length} file${fileUris.length === 1 ? "" : "s"}.`);
 }
 async function fileUrisUnderFolder(config, folderPath) {
-  const entries = await (0, import_promises13.readdir)(folderPath, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(folderPath, { withFileTypes: true });
   const uris = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const path = (0, import_node_path13.join)(folderPath, entry.name);
+    const path = (0, import_node_path14.join)(folderPath, entry.name);
     if (entry.isDirectory()) {
       uris.push(...await fileUrisUnderFolder(config, path));
     } else if (entry.isFile()) {
@@ -13526,11 +14058,11 @@ async function runConsolidationAgent(agent, sources) {
     throw new Error(`${agent} executable was not found.`);
   }
   const prompt = consolidationPrompt(sources);
-  const stagingDir = await (0, import_promises13.mkdtemp)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
-  const promptPath = (0, import_node_path13.join)(stagingDir, "prompt.txt");
+  const stagingDir = await (0, import_promises14.mkdtemp)((0, import_node_path14.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
+  const promptPath = (0, import_node_path14.join)(stagingDir, "prompt.txt");
   try {
-    await (0, import_promises13.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
-    await (0, import_promises13.chmod)(promptPath, 384);
+    await (0, import_promises14.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
+    await (0, import_promises14.chmod)(promptPath, 384);
     const script = consolidationAgentScript(agent, executable);
     const result = await runCommand("sh", ["-lc", script, "threadnote-consolidate", promptPath], {
       allowFailure: true,
@@ -13546,7 +14078,7 @@ async function runConsolidationAgent(agent, sources) {
     }
     return draft;
   } finally {
-    await (0, import_promises13.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises14.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 function consolidationAgentScript(agent, executable) {
@@ -13684,7 +14216,10 @@ function memoryDirectoryUri2(config, kind, status, projectSegment) {
   }
 }
 function localMemoriesRoot(config) {
-  return (0, import_node_path13.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
+  return (0, import_node_path14.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
+}
+function localResourcesRoot(config) {
+  return (0, import_node_path14.join)(config.agentContextHome, "data", "viking", config.account, "resources");
 }
 function localPathForMemoryUri(config, uri) {
   const prefix = `viking://user/${uriSegment(config.user)}/memories`;
@@ -13696,14 +14231,17 @@ function localPathForMemoryUri(config, uri) {
   if (segments.some((segment) => segment === "." || segment === "..")) {
     return void 0;
   }
-  return (0, import_node_path13.join)(localMemoriesRoot(config), ...segments);
+  return (0, import_node_path14.join)(localMemoriesRoot(config), ...segments);
+}
+function isMissingPathError(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 function localPathToMemoryUri(config, path) {
-  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path13.sep).includes("..")) {
+  const relativePath = (0, import_node_path14.relative)(localMemoriesRoot(config), path);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path14.sep).includes("..")) {
     throw new Error(`Path is outside the memories tree: ${path}`);
   }
-  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path13.sep).join("/")}`;
+  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path14.sep).join("/")}`;
 }
 async function ensurePersonalDirectoryChain2(config, ov, directoryUri) {
   const prefix = "viking://";
@@ -13908,7 +14446,7 @@ async function main() {
   program2.command("init-manifest").description("Create or update a per-developer seed manifest from one or more repo roots").option("--dry-run", "Print the manifest without writing it").option("--path <path>", "Manifest path; defaults to THREADNOTE_MANIFEST or ~/.openviking/seed-manifest.yaml").option("--replace", "Replace the manifest instead of merging with existing projects").option("--repo <path>", "Repo root to include; repeat for multiple repos", collectOption, []).action(async (options) => {
     await runInitManifest(getRuntimeConfig(program2), options);
   });
-  program2.command("seed-skills").description("Seed Codex, Claude, and repo-local SKILL.md files as a searchable catalog").option("--dry-run", "Print skill files and ov commands without importing").option("--manifest <path>", "Manifest path for repo-local skill discovery").option("--native", "Use native OpenViking skill ingestion; requires a working VLM config").action(async (options) => {
+  program2.command("seed-skills").description("Seed Codex/Claude skills and Claude command markdown files as a searchable catalog").option("--dry-run", "Print skill files and ov commands without importing").option("--manifest <path>", "Manifest path for repo-local skill discovery").option("--native", "Use native OpenViking skill ingestion; requires a working VLM config").action(async (options) => {
     await runSeedSkills(getRuntimeConfig(program2, options.manifest), options);
   });
   program2.command("mcp-install").description("Install OpenViking MCP config for a supported agent").argument("<agent>", "codex, claude, cursor, or copilot").option("--apply", "Actually modify the selected agent config").option("--name <name>", "MCP server name", OPENVIKING_MCP_NAME).option("--native-http", "Install OpenViking native HTTP MCP endpoint instead of the local stdio adapter").option("--scope <scope>", "Claude MCP config scope: user, local, or project", parseClaudeMcpScope, "user").option("--url <url>", "OpenViking native HTTP MCP URL").option("--bearer-token-env-var <name>", "Environment variable containing the local API key").action(async (agent, options) => {