threadnote 1.0.0 → 1.1.1

package/dist/threadnote.cjs

@@ -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;
 }
@@ -3887,6 +3909,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);
     });
@@ -4241,8 +4266,192 @@ 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 parseRecallHits(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;
+    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;
+        }
+        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;
@@ -7529,9 +7738,19 @@ 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_MAX_REPAIR_TARGETS = 16;
+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,
+    type: "scan-complete"
+  });
   if (targets.length === 0) {
     return { repairedUris: [], skippedRecentUris: [], warnings: [] };
   }
@@ -7540,26 +7759,41 @@ async function repairStaleRecallIndex(config, ov, options = {}) {
   const repairedUris = [];
   const skippedRecentUris = [];
   const warnings = [];
-  for (const target of targets.slice(0, options.maxTargets ?? MAX_REPAIR_TARGETS)) {
+  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];
     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) {
+      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) {
@@ -7568,6 +7802,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) {
@@ -7576,16 +7813,14 @@ async function findStaleRecallIndexTargets(config, options = {}) {
     }
     const sidecars = await staleSidecars(root.path, root.uri);
     if (options.collapseToRoots === true) {
-      if (sidecars.length === 0) {
-        continue;
-      }
-      const parts = sidecars.map((sidecar) => `${sidecar.relativePath}
+      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}`);
-      byUri.set(root.uri, {
-        parts,
-        staleCount: sidecars.length,
-        uri: root.uri
-      });
+        current.staleCount += 1;
+        byUri.set(uri, current);
+      }
       continue;
     }
     for (const sidecar of sidecars) {
@@ -7602,24 +7837,34 @@ ${sidecar.content}`);
     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 = [];
-  for (const uri of result.repairedUris) {
+  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 = [
@@ -7708,6 +7953,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]");
 }
@@ -9686,71 +9943,77 @@ 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 passes = [await recallSearchHits(config, ov, searchArgs(inferredUri), { dryRun })];
+  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 }));
   }
-  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 }));
   }
-  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: options.includeArchived === true,
+    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);
 }
-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);
@@ -10088,29 +10351,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) {
@@ -10309,21 +10568,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`;
@@ -11615,14 +11868,16 @@ 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);
     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 runStreamingSubcommand(options.dryRun === true, threadnoteCommand, ["repair", "--no-post-update"]);
   if (options.postUpdate !== false) {
     const postUpdateArgs = [
       "post-update",
@@ -11632,15 +11887,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 runStreamingSubcommand(options.dryRun === true, threadnoteCommand, postUpdateArgs);
   } else {
     console.log("Skipping post-update migration prompts because --no-post-update was provided.");
   }
@@ -11728,7 +11975,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.");
@@ -11742,10 +11989,12 @@ 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 maybeRun(false, threadnoteCommand, ["start"]);
+    await runStreamingSubcommand(false, threadnoteCommand, ["stop"]);
+    await waitForOpenVikingPortClosed(config, 15e3);
+    await runStreamingSubcommand(false, threadnoteCommand, ["start"]);
   }
   const healthyAfter = await waitForOpenVikingHealthy(config, 1e4);
   if (!healthyAfter) {
@@ -11755,6 +12004,17 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
     console.log("Check the server log or run: threadnote start");
   }
 }
+async function runStreamingSubcommand(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`;
 }
@@ -11778,12 +12038,27 @@ 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_path12.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
 }
@@ -11900,7 +12175,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) {
@@ -12314,16 +12589,41 @@ async function repairRecallIndex(config, dryRun) {
     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,
+      consecutiveFailureLimit: MAINTENANCE_CONSECUTIVE_FAILURE_LIMIT,
       dryRun,
       ignoreBackoff: true,
       includeAgentSkills: true,
       includeManifestResources: true,
-      maxTargets: MAINTENANCE_MAX_REPAIR_TARGETS
+      maxTargets: MAINTENANCE_MAX_REPAIR_TARGETS,
+      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}.`);
+        }
+      }
     });
-    const messages = formatRecallIndexRepairMessages(result, { dryRun });
+    progress.stop();
+    const messages = formatRecallIndexRepairMessages(result, { dryRun, maxUris: 20 });
     if (messages.length === 0) {
       console.log("Recall index freshness OK.");
       return;
@@ -12332,6 +12632,7 @@ async function repairRecallIndex(config, dryRun) {
       console.log(message);
     }
   } catch (err) {
+    progress.stop();
     console.log(`WARN could not repair recall index freshness: ${errorMessage(err)}`);
   }
 }
@@ -12687,6 +12988,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,
@@ -13522,7 +13830,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)
           })
         )
       );
@@ -14381,7 +14690,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 exact memory/resource matches").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) => {