threadnote 1.1.0 → 1.1.2

package/dist/mcp_server.cjs

@@ -36085,8 +36085,201 @@ function exactRecallTerms(query) {
   }
   return terms.sort((left, right) => exactRecallTermScore(right) - exactRecallTermScore(left)).slice(0, 4);
 }
-function grepOutputHasMatches(output) {
-  return !output.includes("matches        []") && !output.includes('"matches":[]') && !output.includes("match_count    0");
+var RECALL_SCORE_THRESHOLD = process.env.THREADNOTE_RECALL_THRESHOLD?.trim() || "0.45";
+var EXACT_SCOPE_INTENT_PATTERNS = [
+  ["preferences", /\b(preferences?|prefer|styles?|tone|voice|writing|persona|communication)\b/i],
+  ["handoffs", /\b(handoffs?|status|next step|in progress|wip|current work|where .* left)\b/i],
+  ["durable", /\b(durable|feature knowledge|design decisions?|invariants?|api contract|gotchas?)\b/i],
+  ["incidents", /\b(incidents?|outage|post-?mortem|on-?call|escalation)\b/i]
+];
+function exactRecallScopeIntents(query) {
+  const intents = /* @__PURE__ */ new Set();
+  for (const [intent, pattern] of EXACT_SCOPE_INTENT_PATTERNS) {
+    if (pattern.test(query)) {
+      intents.add(intent);
+    }
+  }
+  return intents;
+}
+function isSummarySidecarUri(uri) {
+  return /\.(?:overview|abstract)\.md(?:#|$)/.test(uri);
+}
+function grepUrisFromJson(output) {
+  const start = output.search(/^\{/m);
+  if (start < 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(output.slice(start));
+    const result = isJsonObject(parsed) ? parsed.result : void 0;
+    const matches = isJsonObject(result) ? result.matches : void 0;
+    if (!Array.isArray(matches)) {
+      return [];
+    }
+    const uris = [];
+    for (const match of matches) {
+      if (isJsonObject(match) && typeof match.uri === "string" && !isSummarySidecarUri(match.uri)) {
+        uris.push(match.uri);
+      }
+    }
+    return uris;
+  } catch (_err) {
+    return [];
+  }
+}
+function recallSnippet(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length > 180 ? `${oneLine.slice(0, 180)}\u2026` : oneLine;
+}
+function isArchivedMemoryUri(uri) {
+  const documentUri = uri.replace(/#.*$/, "");
+  return /^viking:\/\/user\/[^/]+\/memories\/(?:durable|handoffs|incidents|preferences|smoke)\/archived(?:\/|$)/.test(
+    documentUri
+  );
+}
+function parseRecallHits(output, options = {}) {
+  const start = output.search(/^\{/m);
+  if (start < 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(output.slice(start));
+    const result = isJsonObject(parsed) ? parsed.result : void 0;
+    if (!isJsonObject(result)) {
+      return [];
+    }
+    const hits = [];
+    for (const key of ["memories", "resources", "skills"]) {
+      const items = result[key];
+      if (!Array.isArray(items)) {
+        continue;
+      }
+      for (const item of items) {
+        if (!isJsonObject(item) || typeof item.uri !== "string" || isSummarySidecarUri(item.uri)) {
+          continue;
+        }
+        if (options.includeArchived !== true && isArchivedMemoryUri(item.uri)) {
+          continue;
+        }
+        hits.push({
+          contextType: typeof item.context_type === "string" ? item.context_type : "result",
+          score: typeof item.score === "number" ? item.score : 0,
+          snippet: recallSnippet(item.abstract ?? item.overview),
+          uri: item.uri
+        });
+      }
+    }
+    return hits;
+  } catch (_err) {
+    return [];
+  }
+}
+function mergeRecallHits(passes) {
+  const byDocument = /* @__PURE__ */ new Map();
+  for (const pass of passes) {
+    for (const hit of pass) {
+      const documentUri = hit.uri.replace(/#.*$/, "");
+      const existing = byDocument.get(documentUri);
+      if (!existing || hit.score > existing.score) {
+        byDocument.set(documentUri, { ...hit, uri: documentUri });
+      }
+    }
+  }
+  return [...byDocument.values()].sort((left, right) => right.score - left.score);
+}
+function formatRecallHits(hits, maxHits) {
+  if (hits.length === 0) {
+    return void 0;
+  }
+  const shown = hits.slice(0, maxHits);
+  const lines = shown.flatMap((hit, index) => {
+    const head = `${index + 1}. ${hit.contextType} \xB7 score ${hit.score.toFixed(2)} \xB7 ${hit.uri}`;
+    return hit.snippet ? [head, `   ${hit.snippet}`] : [head];
+  });
+  if (hits.length > maxHits) {
+    lines.push(`(+${hits.length - maxHits} more \u2014 refine the query or read a URI above)`);
+  }
+  return lines.join("\n");
+}
+function exactMemoryScopeUris(params) {
+  const { agentMemoriesUri, includeArchived, intents, projectName, projectResourceUri, userBase } = params;
+  const durable = projectName ? `${userBase}/durable/projects/${projectName}` : `${userBase}/durable/projects`;
+  const handoffs = projectName ? `${userBase}/handoffs/active/${projectName}` : `${userBase}/handoffs/active`;
+  const incidents = projectName ? `${userBase}/incidents/active/${projectName}` : `${userBase}/incidents/active`;
+  if (intents.size > 0) {
+    const scopes2 = [];
+    if (intents.has("preferences")) {
+      scopes2.push(`${userBase}/preferences`);
+    }
+    if (intents.has("durable")) {
+      scopes2.push(durable);
+    }
+    if (intents.has("handoffs")) {
+      scopes2.push(handoffs);
+    }
+    if (intents.has("incidents")) {
+      scopes2.push(incidents);
+    }
+    scopes2.push(`${userBase}/shared`);
+    if (includeArchived) {
+      if (intents.has("durable")) {
+        scopes2.push(`${userBase}/durable/archived`);
+      }
+      if (intents.has("handoffs")) {
+        scopes2.push(`${userBase}/handoffs/archived`);
+      }
+      if (intents.has("incidents")) {
+        scopes2.push(`${userBase}/incidents/archived`);
+      }
+    }
+    return scopes2;
+  }
+  const scopes = [
+    `${userBase}/preferences`,
+    durable,
+    handoffs,
+    incidents,
+    `${userBase}/shared`,
+    agentMemoriesUri,
+    projectResourceUri ?? "viking://resources/repos"
+  ];
+  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+}
+async function collectExactMatches(terms, scopes, runGrep) {
+  const pairs2 = terms.flatMap((term) => scopes.map((scope) => ({ scope, term })));
+  const outputs = await Promise.all(pairs2.map((pair) => runGrep(pair.term, pair.scope)));
+  const byUri = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const [index, pair] of pairs2.entries()) {
+    const json3 = outputs[index];
+    if (!json3) {
+      continue;
+    }
+    for (const raw of grepUrisFromJson(json3)) {
+      const uri = raw.replace(/#.*$/, "");
+      const existing = byUri.get(uri);
+      if (existing) {
+        existing.terms.add(pair.term);
+      } else {
+        byUri.set(uri, { order: order++, terms: /* @__PURE__ */ new Set([pair.term]) });
+      }
+    }
+  }
+  return [...byUri.entries()].sort((left, right) => right[1].terms.size - left[1].terms.size || left[1].order - right[1].order).map(([uri, value]) => ({ terms: [...value.terms], uri }));
+}
+function formatExactMatchPointers(matches, maxUris = 8) {
+  if (matches.length === 0) {
+    return void 0;
+  }
+  const shown = matches.slice(0, maxUris);
+  const lines = shown.map((match) => `- ${match.uri} (${match.terms.join(", ")})`);
+  if (matches.length > maxUris) {
+    lines.push(`(+${matches.length - maxUris} more exact matches \u2014 refine the query to narrow)`);
+  }
+  return ["Exact term matches (read the URI for full content):", ...lines].join("\n");
 }
 function exactRecallTermScore(term) {
   let score = term.length;
@@ -36197,6 +36390,7 @@ async function repairStaleRecallIndex(config2, ov, options = {}) {
   options.onProgress?.({ type: "scan-start" });
   const targets = await findStaleRecallIndexTargets(config2, options);
   const repairTargets = targets.slice(0, options.maxTargets ?? MAX_REPAIR_TARGETS);
+  const consecutiveFailureLimit = options.consecutiveFailureLimit;
   options.onProgress?.({
     repairTargetCount: repairTargets.length,
     totalTargets: targets.length,
@@ -36210,6 +36404,7 @@ async function repairStaleRecallIndex(config2, ov, options = {}) {
   const repairedUris = [];
   const skippedRecentUris = [];
   const warnings = [];
+  let consecutiveFailures = 0;
   for (const [targetIndex, target] of repairTargets.entries()) {
     const progressBase = { index: targetIndex + 1, target, total: repairTargets.length };
     const previous = state.entries[target.uri];
@@ -36230,11 +36425,20 @@ async function repairStaleRecallIndex(config2, ov, options = {}) {
       { allowFailure: true }
     );
     if (result.exitCode === 0) {
+      consecutiveFailures = 0;
       repairedUris.push(target.uri);
       state.entries[target.uri] = { repairedAt: new Date(now).toISOString(), signature: target.signature };
     } else {
+      consecutiveFailures += 1;
       warnings.push(indexRepairWarning(target.uri, result));
       await options.onRepairFailure?.(target, result);
+      const remaining = repairTargets.length - (targetIndex + 1);
+      if (consecutiveFailureLimit !== void 0 && consecutiveFailures >= consecutiveFailureLimit && remaining > 0) {
+        warnings.push(
+          `Stopped recall index repair after ${consecutiveFailures} consecutive reindex failures; skipped ${remaining} remaining scope(s). Re-run \`threadnote repair\` once OpenViking is idle.`
+        );
+        break;
+      }
     }
   }
   if (options.dryRun !== true && repairedUris.length > 0) {
@@ -36243,6 +36447,9 @@ async function repairStaleRecallIndex(config2, ov, options = {}) {
   return { repairedUris, skippedRecentUris, warnings };
 }
 async function findStaleRecallIndexTargets(config2, options = {}) {
+  if (await summaryAutoGenerationDisabled(config2)) {
+    return [];
+  }
   const roots = await scanRoots(config2, options);
   const byUri = /* @__PURE__ */ new Map();
   for (const root of roots) {
@@ -36303,12 +36510,6 @@ function formatRecallIndexRepairMessages(result, options = {}) {
   }
   return messages;
 }
-function filterStaleRecallSummaryRows(output) {
-  return output.split(/\r?\n/).filter((line) => !isStaleRecallSummaryRow(line)).join("\n").trim();
-}
-function isStaleRecallSummaryRow(line) {
-  return /viking:\/\/\S+\/\.(?:abstract|overview)\.md\b/.test(line) && isStaleSummary(line);
-}
 async function scanRoots(config2, options) {
   const accountRoot = (0, import_node_path2.join)(config2.agentContextHome, "data", "viking", config2.account);
   const roots = [
@@ -36397,6 +36598,18 @@ async function staleSidecars(rootPath, rootUri) {
 function isSummarySidecar(name) {
   return name === ".abstract.md" || name === ".overview.md";
 }
+async function summaryAutoGenerationDisabled(config2) {
+  const raw = await readFileIfExists((0, import_node_path2.join)(config2.agentContextHome, "ov.conf"));
+  if (!raw) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isJsonObject(parsed) && parsed.auto_generate_l0 === false && parsed.auto_generate_l1 === false;
+  } catch (_err) {
+    return false;
+  }
+}
 function isStaleSummary(content) {
   return content.includes("[Directory overview is not ready]") || content.includes("[Directory abstract is not ready]");
 }
@@ -37692,7 +37905,7 @@ function registerTools(server, config2) {
     server,
     config2,
     "recall_context",
-    `Search Threadnote context across personal memories and seeded project resources. Returns semantic hits from indexed Threadnote context (handoffs, durable feature memories, preferences, shared team memories) \u2014 and, when the query mentions a project name from the seed manifest, also from that project's seeded guidance (README, AGENTS.md, CLAUDE.md, SKILL.md, docs/**) under viking://resources/repos/<project>. Queries that mention this/current branch are enriched with local git/workspace terms when callerCwd is provided. Include the repo or project name in the query to make the project-guidance pass fire. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.`
+    `Search Threadnote context across personal memories and seeded project resources. Returns semantic hits from indexed Threadnote context (handoffs, durable feature memories, preferences, shared team memories) \u2014 and, when the query mentions a project name from the seed manifest, also from that project's seeded guidance (README, AGENTS.md, CLAUDE.md, SKILL.md, docs/**) under viking://resources/repos/<project>. Queries that mention this/current branch are enriched with local git/workspace terms when callerCwd is provided. Include the repo or project name in the query to make the project-guidance pass fire. Results are filtered by a default relevance threshold (0.5); if a recall comes back empty or too sparse, retry with a lower threshold (e.g. {"query":"...","threshold":0.2}) to broaden. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.`
   );
   registerSearchTool(
     server,
@@ -38213,10 +38426,13 @@ function registerSearchTool(server, config2, name, description) {
         uri: external_exports.string().optional().describe("Optional viking:// subtree to search"),
         callerCwd: external_exports.string().optional().describe("Optional absolute caller workspace path used to resolve this/current branch queries"),
         nodeLimit: external_exports.number().int().positive().max(100).optional().describe("Maximum result count"),
-        includeArchived: external_exports.boolean().optional().describe("Include archived memories in exact memory/resource matches")
+        includeArchived: external_exports.boolean().optional().describe("Include archived memories in recall results"),
+        threshold: external_exports.number().min(0).max(1).optional().describe(
+          "Minimum relevance score 0-1 (default 0.5); lower it (toward 0) to broaden when a recall comes back empty"
+        )
       }
     },
-    async ({ callerCwd, includeArchived, nodeLimit, query, uri }) => {
+    async ({ callerCwd, includeArchived, nodeLimit, query, threshold, uri }) => {
       const checkedQuery = requiredText(query, name, "query", { query: "unity-ui-ccc latest handoff" });
       if (!checkedQuery.ok) {
         return checkedQuery.error;
@@ -38230,7 +38446,8 @@ function registerSearchTool(server, config2, name, description) {
         query: checkedQuery.value,
         pinnedUri: checkedUri.value,
         nodeLimit,
-        includeArchived: includeArchived === true
+        includeArchived: includeArchived === true,
+        threshold: threshold === void 0 ? void 0 : String(threshold)
       });
     }
   );
@@ -38261,36 +38478,40 @@ async function runRecallTool(config2, params) {
   } catch (err) {
     indexRepairMessages = [`Auto-index repair warning: ${errorMessage(err)}`];
   }
-  const contextualParams = { ...params, query };
-  const semanticResult = await runOpenVikingMcpTool(config2, "search", {
-    limit: params.nodeLimit,
-    query,
-    target_uri: params.pinnedUri
-  });
-  if (semanticResult.isError === true) {
-    return semanticResult;
-  }
-  const [firstContent] = semanticResult.content;
-  if (firstContent?.type !== "text") {
-    return semanticResult;
+  const project = params.pinnedUri ? void 0 : await inferProjectFromQuery(config2.manifestPath, projectQuery);
+  const limitArgs = params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : [];
+  const threshold = params.threshold ?? RECALL_SCORE_THRESHOLD;
+  const pinnedArgs = params.pinnedUri ? ["--uri", params.pinnedUri] : [];
+  const base = await recallSearchHits(
+    config2,
+    ["search", query, ...pinnedArgs, ...limitArgs],
+    threshold,
+    params.includeArchived
+  );
+  const passes = [base.hits];
+  const seededUri = project ? trimTrailingSlash(project.uri) : void 0;
+  if (seededUri?.startsWith("viking://") && seededUri !== params.pinnedUri) {
+    const seeded = await recallSearchHits(
+      config2,
+      ["search", params.query, "--uri", seededUri, ...limitArgs],
+      threshold,
+      params.includeArchived
+    );
+    passes.push(seeded.hits);
   }
   const sections = [];
-  const semanticText = filterStaleRecallSummaryRows(firstContent.text);
-  const filteredSemanticText = semanticText !== firstContent.text.trim();
-  if (semanticText) {
-    sections.push(semanticText);
+  const semanticSection = formatRecallHits(mergeRecallHits(passes), params.nodeLimit ?? 12);
+  if (semanticSection) {
+    sections.push(semanticSection);
+  } else if (!base.ok) {
+    sections.push(`Recall semantic search unavailable: ${base.errorText || "ov search failed"}`);
   }
   if (indexRepairMessages.length > 0) {
     sections.push(indexRepairMessages.join("\n"));
   }
-  const seededSection = await seededResourcesSection(config2, contextualParams, projectQuery);
-  if (seededSection) {
-    sections.push(seededSection);
-  }
-  const exactMatches = await exactMemoryMatchesText(config2, query, params.includeArchived);
+  const exactMatches = await exactMemoryMatchesText(config2, query, params.includeArchived, project);
   if (exactMatches) {
-    sections.push(`Exact memory/resource matches:
-${exactMatches}`);
+    sections.push(exactMatches);
   }
   const hygieneHints = await recallHygieneHintsSection(config2, sections.join("\n\n"));
   if (hygieneHints) {
@@ -38302,10 +38523,31 @@ ${exactMatches}`);
   for (const warning2 of syncWarnings) {
     sections.push(`Auto-sync warning: ${warning2}`);
   }
-  if (sections.length <= 1 && !filteredSemanticText) {
-    return semanticResult;
+  if (sections.length === 0) {
+    return { content: [{ type: "text", text: "No recall results found." }] };
+  }
+  const onlyErrorNote = !base.ok && !semanticSection && sections.length === 1;
+  return { content: [{ type: "text", text: sections.join("\n\n") }], isError: onlyErrorNote || void 0 };
+}
+async function recallSearchHits(config2, searchArgs, threshold, includeArchived) {
+  let result = await runOpenVikingTool(config2, [
+    ...searchArgs,
+    "--threshold",
+    threshold,
+    "--level",
+    "2",
+    "--output",
+    "json"
+  ]);
+  if (result.isError === true) {
+    result = await runOpenVikingTool(config2, [...searchArgs, "--output", "json"]);
+  }
+  const firstContent = result.content[0];
+  const text = firstContent?.type === "text" ? firstContent.text : "";
+  if (result.isError === true) {
+    return { errorText: text.trim(), hits: [], ok: false };
   }
-  return { ...semanticResult, content: [{ type: "text", text: sections.join("\n\n") }] };
+  return { errorText: "", hits: parseRecallHits(text, { includeArchived }), ok: true };
 }
 async function recallHygieneHintsSection(config2, recallText) {
   const uris = activePersonalMemoryUrisFromText(recallText, config2.user);
@@ -38316,50 +38558,22 @@ async function recallHygieneHintsSection(config2, recallText) {
   const nudges = recallHygieneNudges(recallText, { records, user: config2.user });
   return nudges.length > 0 ? ["Memory hygiene hints:", ...nudges.map((nudge) => `- ${nudge}`)].join("\n") : void 0;
 }
-async function seededResourcesSection(config2, params, projectQuery) {
-  if (params.pinnedUri) {
-    return void 0;
-  }
-  const project = await inferProjectFromQuery(config2.manifestPath, projectQuery);
-  if (!project) {
-    return void 0;
-  }
-  const projectResourceUri = trimTrailingSlash(project.uri);
-  if (!projectResourceUri.startsWith("viking://")) {
-    return void 0;
-  }
-  const result = await runOpenVikingMcpTool(config2, "search", {
-    limit: params.nodeLimit,
-    query: params.query,
-    target_uri: projectResourceUri
-  });
-  if (result.isError === true) {
-    return void 0;
-  }
-  const body = filterStaleRecallSummaryRows(textFromCallToolResult(result));
-  if (!body) {
-    return void 0;
-  }
-  return `Seeded project resources (${projectResourceUri}):
-${body}`;
-}
-async function exactMemoryMatchesText(config2, query, includeArchived) {
+async function exactMemoryMatchesText(config2, query, includeArchived, project) {
   const terms = exactRecallTerms(query);
   if (terms.length === 0) {
     return void 0;
   }
-  const scopes = exactMemoryScopes(config2, includeArchived);
-  const outputs = [];
-  for (const term of terms) {
-    for (const scope of scopes) {
-      const result = await runOpenVikingMcpTool(config2, "grep", { node_limit: 5, pattern: term, uri: scope });
-      const output = textFromCallToolResult(result);
-      if (result.isError !== true && grepOutputHasMatches(output)) {
-        outputs.push(output);
-      }
-    }
-  }
-  return outputs.length > 0 ? outputs.join("\n\n") : void 0;
+  const ov = await requiredOpenVikingCli2();
+  const scopes = exactMemoryScopes(config2, includeArchived, query, project);
+  const matches = await collectExactMatches(terms, scopes, async (term, scope) => {
+    const result = await runCommand(
+      ov,
+      withIdentity2(config2, ["grep", term, "--uri", scope, "--node-limit", "5", "--output", "json"]),
+      { allowFailure: true }
+    );
+    return result.exitCode === 0 ? result.stdout : void 0;
+  });
+  return formatExactMatchPointers(matches);
 }
 function registerReadTool(server, config2, name, description) {
   server.registerTool(
@@ -38896,21 +39110,15 @@ function vikingDirectoryChain(directoryUri) {
   }
   return chain;
 }
-function exactMemoryScopes(config2, includeArchived) {
-  const userBase = `viking://user/${uriSegment2(config2.user)}/memories`;
-  const scopes = [
-    `${userBase}/preferences`,
-    `${userBase}/durable/projects`,
-    `${userBase}/handoffs/active`,
-    `${userBase}/incidents/active`,
-    `${userBase}/shared`,
-    `viking://agent/${uriSegment2(config2.agentId)}/memories`,
-    // Seeded project resources live outside the user/memories tree. Include
-    // them so exact-term grep surfaces matches in seeded READMEs, AGENTS.md,
-    // SKILL.md, and docs/** alongside personal memory hits.
-    "viking://resources/repos"
-  ];
-  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+function exactMemoryScopes(config2, includeArchived, query, project) {
+  return exactMemoryScopeUris({
+    agentMemoriesUri: `viking://agent/${uriSegment2(config2.agentId)}/memories`,
+    includeArchived,
+    intents: exactRecallScopeIntents(query),
+    projectName: project ? uriSegment2(project.name) : void 0,
+    projectResourceUri: project ? trimTrailingSlash(project.uri) : void 0,
+    userBase: `viking://user/${uriSegment2(config2.user)}/memories`
+  });
 }
 function formatMemoryDocument2(title, metadata, body) {
   const header = [
@@ -39080,6 +39288,16 @@ async function runOpenVikingCliReadTool(config2, uri) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function runOpenVikingTool(config2, args) {
+  try {
+    const ov = await requiredOpenVikingCli2();
+    const result = await runCommand(ov, withIdentity2(config2, args));
+    const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+    return { content: [{ type: "text", text: text || "OK" }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
 async function runOpenVikingMcpTool(config2, toolName, args) {
   const client = new Client({ name: "threadnote-openviking-proxy", version: "1.1.0" });
   try {

package/dist/threadnote.cjs

@@ -3473,6 +3473,7 @@ var {
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
 var DEFAULT_OPENVIKING_VERSION = "0.3.24";
+var OPENVIKING_TOOL_PYTHON = "3.12";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 var OPENVIKING_PACKAGE_NAME = "openviking[local-embed]";
@@ -3909,6 +3910,9 @@ async function resolveRepoName(cwd = getInvocationCwd()) {
 async function runInteractive(executable, args) {
   return new Promise((resolvePromise) => {
     const child = (0, import_node_child_process.spawn)(executable, args, { stdio: "inherit" });
+    child.on("error", () => {
+      resolvePromise(1);
+    });
     child.on("close", (code) => {
       resolvePromise(code ?? 1);
     });
@@ -4263,8 +4267,201 @@ function exactRecallTerms(query) {
   }
   return terms.sort((left, right) => exactRecallTermScore(right) - exactRecallTermScore(left)).slice(0, 4);
 }
-function grepOutputHasMatches(output2) {
-  return !output2.includes("matches        []") && !output2.includes('"matches":[]') && !output2.includes("match_count    0");
+var RECALL_SCORE_THRESHOLD = process.env.THREADNOTE_RECALL_THRESHOLD?.trim() || "0.45";
+var EXACT_SCOPE_INTENT_PATTERNS = [
+  ["preferences", /\b(preferences?|prefer|styles?|tone|voice|writing|persona|communication)\b/i],
+  ["handoffs", /\b(handoffs?|status|next step|in progress|wip|current work|where .* left)\b/i],
+  ["durable", /\b(durable|feature knowledge|design decisions?|invariants?|api contract|gotchas?)\b/i],
+  ["incidents", /\b(incidents?|outage|post-?mortem|on-?call|escalation)\b/i]
+];
+function exactRecallScopeIntents(query) {
+  const intents = /* @__PURE__ */ new Set();
+  for (const [intent, pattern] of EXACT_SCOPE_INTENT_PATTERNS) {
+    if (pattern.test(query)) {
+      intents.add(intent);
+    }
+  }
+  return intents;
+}
+function isSummarySidecarUri(uri) {
+  return /\.(?:overview|abstract)\.md(?:#|$)/.test(uri);
+}
+function grepUrisFromJson(output2) {
+  const start = output2.search(/^\{/m);
+  if (start < 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(output2.slice(start));
+    const result = isJsonObject(parsed) ? parsed.result : void 0;
+    const matches = isJsonObject(result) ? result.matches : void 0;
+    if (!Array.isArray(matches)) {
+      return [];
+    }
+    const uris = [];
+    for (const match of matches) {
+      if (isJsonObject(match) && typeof match.uri === "string" && !isSummarySidecarUri(match.uri)) {
+        uris.push(match.uri);
+      }
+    }
+    return uris;
+  } catch (_err) {
+    return [];
+  }
+}
+function recallSnippet(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length > 180 ? `${oneLine.slice(0, 180)}\u2026` : oneLine;
+}
+function isArchivedMemoryUri(uri) {
+  const documentUri = uri.replace(/#.*$/, "");
+  return /^viking:\/\/user\/[^/]+\/memories\/(?:durable|handoffs|incidents|preferences|smoke)\/archived(?:\/|$)/.test(
+    documentUri
+  );
+}
+function parseRecallHits(output2, options = {}) {
+  const start = output2.search(/^\{/m);
+  if (start < 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(output2.slice(start));
+    const result = isJsonObject(parsed) ? parsed.result : void 0;
+    if (!isJsonObject(result)) {
+      return [];
+    }
+    const hits = [];
+    for (const key of ["memories", "resources", "skills"]) {
+      const items = result[key];
+      if (!Array.isArray(items)) {
+        continue;
+      }
+      for (const item of items) {
+        if (!isJsonObject(item) || typeof item.uri !== "string" || isSummarySidecarUri(item.uri)) {
+          continue;
+        }
+        if (options.includeArchived !== true && isArchivedMemoryUri(item.uri)) {
+          continue;
+        }
+        hits.push({
+          contextType: typeof item.context_type === "string" ? item.context_type : "result",
+          score: typeof item.score === "number" ? item.score : 0,
+          snippet: recallSnippet(item.abstract ?? item.overview),
+          uri: item.uri
+        });
+      }
+    }
+    return hits;
+  } catch (_err) {
+    return [];
+  }
+}
+function mergeRecallHits(passes) {
+  const byDocument = /* @__PURE__ */ new Map();
+  for (const pass of passes) {
+    for (const hit of pass) {
+      const documentUri = hit.uri.replace(/#.*$/, "");
+      const existing = byDocument.get(documentUri);
+      if (!existing || hit.score > existing.score) {
+        byDocument.set(documentUri, { ...hit, uri: documentUri });
+      }
+    }
+  }
+  return [...byDocument.values()].sort((left, right) => right.score - left.score);
+}
+function formatRecallHits(hits, maxHits) {
+  if (hits.length === 0) {
+    return void 0;
+  }
+  const shown = hits.slice(0, maxHits);
+  const lines = shown.flatMap((hit, index) => {
+    const head = `${index + 1}. ${hit.contextType} \xB7 score ${hit.score.toFixed(2)} \xB7 ${hit.uri}`;
+    return hit.snippet ? [head, `   ${hit.snippet}`] : [head];
+  });
+  if (hits.length > maxHits) {
+    lines.push(`(+${hits.length - maxHits} more \u2014 refine the query or read a URI above)`);
+  }
+  return lines.join("\n");
+}
+function exactMemoryScopeUris(params) {
+  const { agentMemoriesUri, includeArchived, intents, projectName, projectResourceUri, userBase } = params;
+  const durable = projectName ? `${userBase}/durable/projects/${projectName}` : `${userBase}/durable/projects`;
+  const handoffs = projectName ? `${userBase}/handoffs/active/${projectName}` : `${userBase}/handoffs/active`;
+  const incidents = projectName ? `${userBase}/incidents/active/${projectName}` : `${userBase}/incidents/active`;
+  if (intents.size > 0) {
+    const scopes2 = [];
+    if (intents.has("preferences")) {
+      scopes2.push(`${userBase}/preferences`);
+    }
+    if (intents.has("durable")) {
+      scopes2.push(durable);
+    }
+    if (intents.has("handoffs")) {
+      scopes2.push(handoffs);
+    }
+    if (intents.has("incidents")) {
+      scopes2.push(incidents);
+    }
+    scopes2.push(`${userBase}/shared`);
+    if (includeArchived) {
+      if (intents.has("durable")) {
+        scopes2.push(`${userBase}/durable/archived`);
+      }
+      if (intents.has("handoffs")) {
+        scopes2.push(`${userBase}/handoffs/archived`);
+      }
+      if (intents.has("incidents")) {
+        scopes2.push(`${userBase}/incidents/archived`);
+      }
+    }
+    return scopes2;
+  }
+  const scopes = [
+    `${userBase}/preferences`,
+    durable,
+    handoffs,
+    incidents,
+    `${userBase}/shared`,
+    agentMemoriesUri,
+    projectResourceUri ?? "viking://resources/repos"
+  ];
+  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+}
+async function collectExactMatches(terms, scopes, runGrep) {
+  const pairs2 = terms.flatMap((term) => scopes.map((scope) => ({ scope, term })));
+  const outputs = await Promise.all(pairs2.map((pair) => runGrep(pair.term, pair.scope)));
+  const byUri = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const [index, pair] of pairs2.entries()) {
+    const json2 = outputs[index];
+    if (!json2) {
+      continue;
+    }
+    for (const raw of grepUrisFromJson(json2)) {
+      const uri = raw.replace(/#.*$/, "");
+      const existing = byUri.get(uri);
+      if (existing) {
+        existing.terms.add(pair.term);
+      } else {
+        byUri.set(uri, { order: order++, terms: /* @__PURE__ */ new Set([pair.term]) });
+      }
+    }
+  }
+  return [...byUri.entries()].sort((left, right) => right[1].terms.size - left[1].terms.size || left[1].order - right[1].order).map(([uri, value]) => ({ terms: [...value.terms], uri }));
+}
+function formatExactMatchPointers(matches, maxUris = 8) {
+  if (matches.length === 0) {
+    return void 0;
+  }
+  const shown = matches.slice(0, maxUris);
+  const lines = shown.map((match) => `- ${match.uri} (${match.terms.join(", ")})`);
+  if (matches.length > maxUris) {
+    lines.push(`(+${matches.length - maxUris} more exact matches \u2014 refine the query to narrow)`);
+  }
+  return ["Exact term matches (read the URI for full content):", ...lines].join("\n");
 }
 function exactRecallTermScore(term) {
   let score = term.length;
@@ -7553,10 +7750,12 @@ var MAX_SCAN_DEPTH = 5;
 var MAX_REPAIR_TARGETS = 4;
 var MAINTENANCE_COLLAPSE_DEPTH = 3;
 var MAINTENANCE_MAX_REPAIR_TARGETS = 512;
+var MAINTENANCE_CONSECUTIVE_FAILURE_LIMIT = 5;
 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);
+  const consecutiveFailureLimit = options.consecutiveFailureLimit;
   options.onProgress?.({
     repairTargetCount: repairTargets.length,
     totalTargets: targets.length,
@@ -7570,6 +7769,7 @@ async function repairStaleRecallIndex(config, ov, options = {}) {
   const repairedUris = [];
   const skippedRecentUris = [];
   const warnings = [];
+  let consecutiveFailures = 0;
   for (const [targetIndex, target] of repairTargets.entries()) {
     const progressBase = { index: targetIndex + 1, target, total: repairTargets.length };
     const previous = state.entries[target.uri];
@@ -7590,11 +7790,20 @@ async function repairStaleRecallIndex(config, ov, options = {}) {
       { allowFailure: true }
     );
     if (result.exitCode === 0) {
+      consecutiveFailures = 0;
       repairedUris.push(target.uri);
       state.entries[target.uri] = { repairedAt: new Date(now).toISOString(), signature: target.signature };
     } else {
+      consecutiveFailures += 1;
       warnings.push(indexRepairWarning(target.uri, result));
       await options.onRepairFailure?.(target, result);
+      const remaining = repairTargets.length - (targetIndex + 1);
+      if (consecutiveFailureLimit !== void 0 && consecutiveFailures >= consecutiveFailureLimit && remaining > 0) {
+        warnings.push(
+          `Stopped recall index repair after ${consecutiveFailures} consecutive reindex failures; skipped ${remaining} remaining scope(s). Re-run \`threadnote repair\` once OpenViking is idle.`
+        );
+        break;
+      }
     }
   }
   if (options.dryRun !== true && repairedUris.length > 0) {
@@ -7603,6 +7812,9 @@ async function repairStaleRecallIndex(config, ov, options = {}) {
   return { repairedUris, skippedRecentUris, warnings };
 }
 async function findStaleRecallIndexTargets(config, options = {}) {
+  if (await summaryAutoGenerationDisabled(config)) {
+    return [];
+  }
   const roots = await scanRoots(config, options);
   const byUri = /* @__PURE__ */ new Map();
   for (const root of roots) {
@@ -7663,12 +7875,6 @@ function formatRecallIndexRepairMessages(result, options = {}) {
   }
   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 = [
@@ -7757,6 +7963,18 @@ async function staleSidecars(rootPath, rootUri) {
 function isSummarySidecar(name) {
   return name === ".abstract.md" || name === ".overview.md";
 }
+async function summaryAutoGenerationDisabled(config) {
+  const raw = await readFileIfExists((0, import_node_path4.join)(config.agentContextHome, "ov.conf"));
+  if (!raw) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isJsonObject(parsed) && parsed.auto_generate_l0 === false && parsed.auto_generate_l1 === false;
+  } catch (_err) {
+    return false;
+  }
+}
 function isStaleSummary(content) {
   return content.includes("[Directory overview is not ready]") || content.includes("[Directory abstract is not ready]");
 }
@@ -9735,71 +9953,80 @@ async function runRecall(config, options) {
   for (const message of indexRepairMessages) {
     console.log(message);
   }
+  const dryRun = options.dryRun === true;
   const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, projectQuery));
-  const args = ["search", query];
+  const project = await inferProjectFromQuery(config.manifestPath, options.project ?? projectQuery);
+  const nodeLimit = options.nodeLimit ? parsePositiveInteger(options.nodeLimit, "node limit") : void 0;
+  const searchArgs = (scopeUri) => [
+    "search",
+    query,
+    "--threshold",
+    options.threshold ?? RECALL_SCORE_THRESHOLD,
+    "--level",
+    "2",
+    ...scopeUri ? ["--uri", scopeUri] : [],
+    ...nodeLimit ? ["--node-limit", String(nodeLimit)] : []
+  ];
   if (inferredUri) {
-    args.push("--uri", inferredUri);
     console.log(`Recall scope: ${inferredUri}`);
   }
-  if (options.nodeLimit) {
-    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  const includeArchived = options.includeArchived === true;
+  const passes = [
+    await recallSearchHits(config, ov, searchArgs(inferredUri), { dryRun, includeArchived })
+  ];
+  if (options.project && project) {
+    const projectMemoryUri = `viking://user/${uriSegment(config.user)}/memories/durable/projects/${uriSegment(project.name)}`;
+    passes.push(await recallSearchHits(config, ov, searchArgs(projectMemoryUri), { dryRun, includeArchived }));
   }
-  const recallOutputs = [];
-  const baseOutput = await runRecallSearch(config, ov, args, { dryRun: options.dryRun === true });
-  if (baseOutput) {
-    recallOutputs.push(baseOutput);
+  const seededUri = project ? trimTrailingSlash(project.uri) : void 0;
+  if (seededUri?.startsWith("viking://") && seededUri !== inferredUri && !options.uri && options.inferScope !== false) {
+    passes.push(await recallSearchHits(config, ov, searchArgs(seededUri), { dryRun, includeArchived }));
   }
-  const seededOutput = await augmentRecallWithSeededResources(
-    config,
-    ov,
-    { ...options, query },
-    inferredUri,
-    projectQuery
-  );
-  if (seededOutput) {
-    recallOutputs.push(seededOutput);
+  const recallOutputs = [];
+  const semanticSection = formatRecallHits(mergeRecallHits(passes), nodeLimit ?? 12);
+  if (semanticSection) {
+    console.log(`
+${semanticSection}`);
+    recallOutputs.push(semanticSection);
   }
   const exactOutput = await printExactMemoryMatches(config, ov, query, {
-    dryRun: options.dryRun === true,
-    includeArchived: options.includeArchived === true
+    dryRun,
+    includeArchived,
+    project
   });
   if (exactOutput) {
     recallOutputs.push(exactOutput);
   }
   await printRecallHygieneNudges(config, recallOutputs.join("\n"));
 }
-async function augmentRecallWithSeededResources(config, ov, options, inferredUri, projectQuery = options.query) {
-  if (options.uri || options.inferScope === false) {
-    return void 0;
-  }
-  const project = await inferProjectFromQuery(config.manifestPath, projectQuery);
-  if (!project) {
-    return void 0;
+async function recallSearchHits(config, ov, args, options) {
+  const jsonArgs = withIdentity(config, [...args, "--output", "json"]);
+  console.log(`${options.dryRun ? "Would run" : "Running"}: ${formatShellCommand(ov, jsonArgs)}`);
+  if (options.dryRun) {
+    return [];
   }
-  const projectResourceUri = trimTrailingSlash(project.uri);
-  if (!projectResourceUri.startsWith("viking://") || projectResourceUri === inferredUri) {
-    return void 0;
+  let result = await runCommand(ov, jsonArgs, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    result = await runCommand(ov, withIdentity(config, [...stripAdvancedSearchFlags(args), "--output", "json"]), {
+      allowFailure: true
+    });
   }
-  const args = ["search", options.query, "--uri", projectResourceUri];
-  if (options.nodeLimit) {
-    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  if (result.exitCode !== 0) {
+    console.log(`WARN recall search failed: ${result.stderr.trim() || result.stdout.trim() || "ov search error"}`);
+    return [];
   }
-  console.log(`
-Also searching seeded resources: ${projectResourceUri}`);
-  return runRecallSearch(config, ov, args, { dryRun: options.dryRun === true });
+  return parseRecallHits(result.stdout, { includeArchived: options.includeArchived });
 }
-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);
+function stripAdvancedSearchFlags(args) {
+  const stripped = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--threshold" || args[index] === "--level") {
+      index += 1;
+      continue;
+    }
+    stripped.push(args[index]);
   }
-  return output2 || void 0;
+  return stripped;
 }
 async function runRead(config, uri, options) {
   assertVikingUri(uri);
@@ -10137,29 +10364,25 @@ async function printExactMemoryMatches(config, ov, query, options) {
   if (terms.length === 0) {
     return void 0;
   }
-  const scopes = exactMemoryScopes(config, options.includeArchived);
-  const outputs = [];
-  for (const term of terms) {
-    for (const scope of scopes) {
-      const args = withIdentity(config, ["grep", term, "--uri", scope, "--node-limit", "5"]);
-      if (options.dryRun) {
-        outputs.push(formatShellCommand(ov, args));
-        continue;
-      }
-      const result = await runCommand(ov, args, { allowFailure: true });
-      const output3 = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-      if (result.exitCode === 0 && grepOutputHasMatches(output3)) {
-        outputs.push(output3);
-      }
-    }
-  }
-  if (outputs.length === 0) {
+  const scopes = exactMemoryScopes(config, options.includeArchived, query, options.project);
+  const grepArgs = (term, scope) => withIdentity(config, ["grep", term, "--uri", scope, "--node-limit", "5", "--output", "json"]);
+  if (options.dryRun) {
+    const planned = terms.flatMap((term) => scopes.map((scope) => formatShellCommand(ov, grepArgs(term, scope))));
+    console.log("\nExact memory/resource matches:");
+    console.log(planned.join("\n"));
+    return planned.join("\n");
+  }
+  const matches = await collectExactMatches(terms, scopes, async (term, scope) => {
+    const result = await runCommand(ov, grepArgs(term, scope), { allowFailure: true });
+    return result.exitCode === 0 ? result.stdout : void 0;
+  });
+  const text = formatExactMatchPointers(matches);
+  if (!text) {
     return void 0;
   }
-  console.log("\nExact memory/resource matches:");
-  const output2 = outputs.join("\n\n");
-  console.log(output2);
-  return output2;
+  console.log(`
+${text}`);
+  return text;
 }
 async function storeMemory(config, options) {
   if (options.replaceUri) {
@@ -10358,21 +10581,15 @@ async function legacyLifecycleHandoffCandidates(config, limit) {
 function lifecycleMigrationUri(config, metadata, hash) {
   return `${memoryDirectoryUri(config, metadata)}/legacy-${hash.slice(0, 16)}.md`;
 }
-function exactMemoryScopes(config, includeArchived) {
-  const userBase = `viking://user/${uriSegment(config.user)}/memories`;
-  const scopes = [
-    `${userBase}/preferences`,
-    `${userBase}/durable/projects`,
-    `${userBase}/handoffs/active`,
-    `${userBase}/incidents/active`,
-    `${userBase}/shared`,
-    `viking://agent/${uriSegment(config.agentId)}/memories`,
-    // Seeded project resources (READMEs, AGENTS.md, SKILL.md, docs/**) live
-    // under viking://resources/repos/<project>. Include them so an exact-term
-    // grep in a recall surfaces matches in seeded guidance, not only memories.
-    "viking://resources/repos"
-  ];
-  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+function exactMemoryScopes(config, includeArchived, query, project) {
+  return exactMemoryScopeUris({
+    agentMemoriesUri: `viking://agent/${uriSegment(config.agentId)}/memories`,
+    includeArchived,
+    intents: exactRecallScopeIntents(query),
+    projectName: project ? uriSegment(project.name) : void 0,
+    projectResourceUri: project ? trimTrailingSlash(project.uri) : void 0,
+    userBase: `viking://user/${uriSegment(config.user)}/memories`
+  });
 }
 function memoryUriFor(config, memory, metadata) {
   const filename = shouldUseStableMemoryUri(metadata) ? `${uriSegment(metadata.topic ?? "current")}.md` : `threadnote-${safeTimestamp()}-${sha256(memory).slice(0, 12)}.md`;
@@ -11664,7 +11881,7 @@ async function runUpdate(config, options) {
   }
   const runtime = await resolveUpdateRuntime(options.runtime ?? "auto");
   const updateCommand = updatePackageCommand(runtime, registry);
-  await maybeRun(options.dryRun === true, updateCommand.executable, updateCommand.args);
+  await runStreamingSubcommand(options.dryRun === true, updateCommand.executable, updateCommand.args);
   if (options.repair === false) {
     console.log("Skipping repair because --no-repair was provided.");
     await printWhatsNewIfAvailable(info2);
@@ -11673,7 +11890,7 @@ async function runUpdate(config, options) {
   const threadnoteCommand = await installedThreadnoteCommand(runtime);
   console.log("");
   console.log("Repairing local Threadnote setup after package update.");
-  await runThreadnoteSubcommand(options.dryRun === true, threadnoteCommand, ["repair", "--no-post-update"]);
+  await runStreamingSubcommand(options.dryRun === true, threadnoteCommand, ["repair", "--no-post-update"]);
   if (options.postUpdate !== false) {
     const postUpdateArgs = [
       "post-update",
@@ -11683,7 +11900,7 @@ async function runUpdate(config, options) {
       info2.latestVersion,
       ...options.yes === true ? ["--yes"] : []
     ];
-    await runThreadnoteSubcommand(options.dryRun === true, threadnoteCommand, postUpdateArgs);
+    await runStreamingSubcommand(options.dryRun === true, threadnoteCommand, postUpdateArgs);
   } else {
     console.log("Skipping post-update migration prompts because --no-post-update was provided.");
   }
@@ -11771,7 +11988,7 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
   const wasRunning = await isOpenVikingHealthy(config);
   const usingLaunchd = await isLaunchAgentInstalled();
   const threadnoteCommand = currentThreadnoteCommand() ?? await findExecutable([NPM_PACKAGE_NAME]) ?? NPM_PACKAGE_NAME;
-  await maybeRun(options.dryRun, threadnoteCommand, ["install", "--force", "--no-start"]);
+  await runStreamingSubcommand(options.dryRun, threadnoteCommand, ["install", "--force", "--no-start"]);
   if (options.dryRun) {
     if (wasRunning || usingLaunchd) {
       console.log("Would restart OpenViking server so the new binary takes effect.");
@@ -11788,9 +12005,9 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
     await waitForOpenVikingPortClosed(config, 15e3);
     await runCommand("launchctl", ["load", launchAgentPath], { allowFailure: true });
   } else {
-    await maybeRun(false, threadnoteCommand, ["stop"]);
+    await runStreamingSubcommand(false, threadnoteCommand, ["stop"]);
     await waitForOpenVikingPortClosed(config, 15e3);
-    await maybeRun(false, threadnoteCommand, ["start"]);
+    await runStreamingSubcommand(false, threadnoteCommand, ["start"]);
   }
   const healthyAfter = await waitForOpenVikingHealthy(config, 1e4);
   if (!healthyAfter) {
@@ -11800,7 +12017,7 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
     console.log("Check the server log or run: threadnote start");
   }
 }
-async function runThreadnoteSubcommand(dryRun, executable, args) {
+async function runStreamingSubcommand(dryRun, executable, args) {
   if (dryRun) {
     await maybeRun(true, executable, args);
     return;
@@ -11971,7 +12188,7 @@ async function runApplicablePostUpdateMigrations(config, options) {
       console.log(`  ${formatMigrationCommand(threadnoteCommand, migration.commandArgs)}`);
       continue;
     }
-    await maybeRun(options.dryRun, threadnoteCommand, migration.commandArgs);
+    await runStreamingSubcommand(options.dryRun, threadnoteCommand, migration.commandArgs);
     if (!options.dryRun) {
       handledMigrationIds.add(migration.id);
       for (const instruction of migration.instructions) {
@@ -12238,6 +12455,14 @@ async function runInstall(config, options) {
     serverInstallRan = true;
   }
   const resolvedServerPath = serverInstallRan ? await findOpenVikingServer() : serverPath;
+  if (serverInstallRan && !resolvedServerPath && !dryRun) {
+    const message = `OpenViking install ran but ${OPENVIKING_SERVER_COMMAND} was not found on PATH, in the uv tool bin dir, or ~/.local/bin. Re-run \`threadnote install --force\` (it streams the full build), then \`threadnote doctor\`.`;
+    if (options.requireServerBinary === false) {
+      console.warn(`WARN ${message}`);
+    } else {
+      throw new Error(message);
+    }
+  }
   if (resolvedServerPath && !dryRun) {
     await maybePrintOpenVikingPathHint(resolvedServerPath);
   }
@@ -12274,6 +12499,7 @@ async function runRepair(config, options) {
     packageManager: options.packageManager,
     printNextSteps: false,
     repairInvalidConfigs: true,
+    requireServerBinary: false,
     start: false
   });
   await repairManifest(config, dryRun);
@@ -12390,15 +12616,12 @@ async function repairRecallIndex(config, dryRun) {
     const result = await repairStaleRecallIndex(config, ov, {
       collapseDepth: MAINTENANCE_COLLAPSE_DEPTH,
       collapseToRoots: true,
+      consecutiveFailureLimit: MAINTENANCE_CONSECUTIVE_FAILURE_LIMIT,
       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) {
@@ -12631,7 +12854,11 @@ async function openVikingServerCheck() {
   const name = OPENVIKING_SERVER_COMMAND;
   const executable = await findOpenVikingServer();
   if (!executable) {
-    return { name, status: "fail", detail: "missing; install will fetch it via uv or pipx" };
+    return {
+      name,
+      status: "fail",
+      detail: "missing; run `threadnote install` to fetch it via uv or pipx (local-embed may compile from source on first install)"
+    };
   }
   const result = await runCommand(executable, ["--help"], { allowFailure: true });
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
@@ -12787,6 +13014,13 @@ async function manifestCheck(path) {
 }
 async function recallIndexFreshnessCheck(config) {
   try {
+    if (await summaryAutoGenerationDisabled(config)) {
+      return {
+        name: "recall index freshness",
+        status: "ok",
+        detail: "OpenViking L0/L1 summary auto-generation disabled in ov.conf; directory summary placeholders are expected and not reindexed"
+      };
+    }
     const targets = await findStaleRecallIndexTargets(config, {
       collapseToRoots: true,
       includeAgentSkills: true,
@@ -12858,7 +13092,36 @@ async function runInstallCommands(config, preferred, force, dryRun) {
   }
   const installCommands = await getInstallCommands(config, manager, force);
   for (const installCommand of installCommands) {
-    await maybeRun(dryRun, installCommand.executable, installCommand.args);
+    if (dryRun) {
+      await maybeRun(true, installCommand.executable, installCommand.args);
+      continue;
+    }
+    console.log(`Running: ${formatShellCommand(installCommand.executable, installCommand.args)}`);
+    const exitCode = await runInteractive(installCommand.executable, installCommand.args);
+    if (exitCode !== 0) {
+      printOpenVikingInstallFailureHelp(installCommand);
+      throw new Error(`${formatShellCommand(installCommand.executable, installCommand.args)} exited with ${exitCode}.`);
+    }
+  }
+}
+function printOpenVikingInstallFailureHelp(failedCommand) {
+  console.error("");
+  console.error("OpenViking install did not complete.");
+  console.error(
+    "openviking[local-embed] includes llama-cpp-python, which compiles from source when no prebuilt wheel matches your Python/platform \u2014 that build can run 10-20 minutes and is memory-heavy, so it may be killed by the OS (out of memory) or look stuck."
+  );
+  console.error("Re-run it directly to see full output without any wrapper timeout:");
+  console.error(`  ${formatShellCommand(failedCommand.executable, failedCommand.args)}`);
+  console.error("Cap memory use during the compile with: CMAKE_BUILD_PARALLEL_LEVEL=2 <command above>");
+  if (failedCommand.executable === "uv") {
+    if (failedCommand.args.includes("--python")) {
+      console.error(
+        "If uv could not fetch a managed CPython (offline or restricted network), drop the version pin and retry: THREADNOTE_OPENVIKING_PYTHON= threadnote install --force"
+      );
+    }
+    console.error("If it was killed mid-build, clear the partial install first, then retry:");
+    console.error("  uv cache clean");
+    console.error('  rm -rf "$(uv tool dir)/openviking"');
   }
 }
 async function offerToInstallUv() {
@@ -12939,12 +13202,33 @@ async function getPythonSystemCertificatesInstallCommand(serverPath) {
   }
   return { executable: pythonPath, args: ["-m", "pip", "install", PYTHON_SYSTEM_CERTS_PACKAGE] };
 }
+function localEmbedWheelIndexUrl() {
+  const override = process.env.THREADNOTE_LLAMA_WHEEL_INDEX;
+  if (override !== void 0) {
+    return override.trim() === "" ? void 0 : override.trim();
+  }
+  const base = "https://abetlen.github.io/llama-cpp-python/whl";
+  return (0, import_node_os6.platform)() === "darwin" ? `${base}/metal` : `${base}/cpu`;
+}
+function openVikingToolPython() {
+  const override = process.env.THREADNOTE_OPENVIKING_PYTHON;
+  if (override !== void 0) {
+    return override.trim() === "" ? void 0 : override.trim();
+  }
+  return OPENVIKING_TOOL_PYTHON;
+}
 async function getInstallCommands(config, preferred, force) {
   const packageSpec = `${OPENVIKING_PACKAGE_NAME}==${config.openVikingVersion}`;
+  const wheelIndex = localEmbedWheelIndexUrl();
   const manager = preferred ?? await detectPackageManager();
   if (manager === "pipx") {
+    const installArgs = force ? ["install", "--force"] : ["install"];
+    if (wheelIndex) {
+      installArgs.push("--pip-args", `--extra-index-url ${wheelIndex}`);
+    }
+    installArgs.push(packageSpec);
     return [
-      { executable: "pipx", args: force ? ["install", "--force", packageSpec] : ["install", packageSpec] },
+      { executable: "pipx", args: installArgs },
       {
         executable: "pipx",
         args: force ? ["inject", "--force", "openviking", PYTHON_SYSTEM_CERTS_PACKAGE] : ["inject", "openviking", PYTHON_SYSTEM_CERTS_PACKAGE]
@@ -12952,7 +13236,16 @@ async function getInstallCommands(config, preferred, force) {
     ];
   }
   if (manager === "uv") {
-    const uvArgs = ["tool", "install", "--native-tls", "--with", PYTHON_SYSTEM_CERTS_PACKAGE];
+    const toolPython = openVikingToolPython();
+    const uvArgs = [
+      "tool",
+      "install",
+      "--native-tls",
+      ...toolPython ? ["--python", toolPython] : [],
+      "--with",
+      PYTHON_SYSTEM_CERTS_PACKAGE,
+      ...wheelIndex ? ["--extra-index-url", wheelIndex] : []
+    ];
     return [
       {
         executable: "uv",
@@ -12964,6 +13257,9 @@ async function getInstallCommands(config, preferred, force) {
   if (force) {
     pipArgs.push("--upgrade", "--force-reinstall");
   }
+  if (wheelIndex) {
+    pipArgs.push("--extra-index-url", wheelIndex);
+  }
   pipArgs.push(PYTHON_SYSTEM_CERTS_PACKAGE);
   pipArgs.push(packageSpec);
   return [{ executable: "python3", args: pipArgs }];
@@ -13622,7 +13918,8 @@ async function handleRequest(context, request, response) {
         await runCaptured(
           () => runRecall(context.config, {
             query: requireString(body.query, "query"),
-            nodeLimit: optionalString(body.nodeLimit)
+            nodeLimit: optionalString(body.nodeLimit),
+            project: optionalString(body.project)
           })
         )
       );
@@ -14481,7 +14778,7 @@ async function main() {
   program2.command("migrate-lifecycle").description("Move clear legacy handoff memories into lifecycle-aware archive paths").option("--apply", "Perform the migration; without this, prints a dry run").option("--dry-run", "Print migration actions without writing or removing memories").option("--limit <count>", "Maximum number of legacy handoffs to migrate").action(async (options) => {
     await runMigrateLifecycle(getRuntimeConfig(program2), options);
   });
-  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in exact memory/resource matches").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--uri <uri>", "Restrict search to a viking:// URI").action(async (options) => {
+  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in recall results").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").action(async (options) => {
     await runRecall(getRuntimeConfig(program2), options);
   });
   program2.command("compact").description("Plan or apply scoped memory hygiene for active personal memories").requiredOption("--project <name>", "Project/repo namespace to inspect").option("--apply", "Apply the compact plan; without this, prints a dry run").option("--dry-run", "Print the compact plan without changing anything").option("--kind <kind>", "durable, handoff, or incident", parseCompactKind).option("--topic <name>", "Stable topic name to inspect").action(async (options) => {

package/manager/app.js

@@ -34760,6 +34760,7 @@
     const [toast, setToast] = (0, import_react2.useState)("");
     const [output, setOutput] = (0, import_react2.useState)("");
     const [recallQuery, setRecallQuery] = (0, import_react2.useState)("");
+    const [recallProject, setRecallProject] = (0, import_react2.useState)("");
     const [readUri, setReadUri] = (0, import_react2.useState)("");
     const [compactProject, setCompactProject] = (0, import_react2.useState)("");
     const [compactTopic, setCompactTopic] = (0, import_react2.useState)("");
@@ -35671,12 +35672,23 @@
                   placeholder: "Search memories and seeded resources"
                 }
               ),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                "input",
+                {
+                  value: recallProject,
+                  onChange: (event) => setRecallProject(event.target.value),
+                  placeholder: "project scope (blank = all)"
+                }
+              ),
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
                 "button",
                 {
                   onClick: () => void runAction(
                     "Recall complete",
-                    () => api("/api/recall", { query: recallQuery }).then((result) => result)
+                    () => api("/api/recall", {
+                      query: recallQuery,
+                      ...recallProject.trim() ? { project: recallProject.trim() } : {}
+                    }).then((result) => result)
                   ),
                   children: "Search"
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",