threadnote 1.4.3 → 1.4.5

package/config/post-update-migrations.json

@@ -18,21 +18,6 @@
         "If Threadnote reported any original files were still being processed, rerun the printed threadnote forget <uri> command later."
       ],
       "requiresLegacyHandoffs": true
-    },
-    {
-      "id": "ov-semantic-poison-hotfix-2734",
-      "introducedIn": "1.4.3",
-      "title": "Patch OpenViking against the semantic-queue poison loop (#2734)",
-      "description": [
-        "OpenViking 0.4.x can deadlock its semantic queue: a memory file reindexed with mode=semantic_and_vectors enqueues a directory-level semantic message whose URI is a file; the processor lists it, fails, and the message re-enqueues forever (it is AGFS-persisted, so it survives a server restart).",
-        "This patches the installed OpenViking to skip non-directory/missing memory URIs (upstream fix PR #2735) and restarts the server so any stuck message drains on the next dequeue.",
-        "It is a no-op when the installed OpenViking already includes the fix, a backup of the original file is kept, and the patched file is compile-checked before it is written."
-      ],
-      "commandArgs": ["repair-semantic-queue", "--apply"],
-      "instructions": [
-        "If the semantic queue was stuck it should now drain. Verify with: ov observer queue",
-        "This is a temporary local patch; it is superseded automatically once Threadnote pins an OpenViking release that includes the fix. Re-run manually any time with: threadnote repair-semantic-queue --apply"
-      ]
     }
   ]
 }

package/dist/threadnote.cjs

@@ -3394,7 +3394,7 @@ var program = new Command();
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.4.4";
+var DEFAULT_OPENVIKING_VERSION = "0.4.5";
 var OPENVIKING_TOOL_PYTHON = "3.12";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
@@ -13703,6 +13703,7 @@ function isUpdateNotificationDisabled() {
 }
 
 // src/lifecycle.ts
+var INSTALL_OUTPUT_TAIL_CHARS = 64e3;
 async function runDoctor(config, options) {
   const checks = await collectDoctorChecks(config, options);
   for (const check of checks) {
@@ -14487,32 +14488,169 @@ async function runInstallCommands(config, preferred, force, dryRun) {
       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}.`);
+    const result = await runInstallCommand(installCommand);
+    if (result.exitCode !== 0) {
+      const commandOutput = `${result.stderr}
+${result.stdout}`;
+      const retry = openVikingSourceBuildRetryForArchiveFailure(installCommand, commandOutput);
+      if (retry) {
+        console.error("");
+        console.error(
+          "The prebuilt llama-cpp-python wheel failed ZIP archive validation; retrying with a local source build."
+        );
+        console.error("This avoids the rejected wheel and can take 10-20 minutes.");
+        console.log(`Running: ${formatInstallCommand(retry.command, retry.env)}`);
+        const retryResult = await runInstallCommand(retry.command, retry.env);
+        if (retryResult.exitCode === 0) {
+          continue;
+        }
+        printOpenVikingInstallFailureHelp(retry.command, `${retryResult.stderr}
+${retryResult.stdout}`);
+        throw new Error(
+          `${formatInstallCommand(retry.command, retry.env)} exited with ${retryResult.exitCode} after automatic source-build retry.`
+        );
+      }
+      printOpenVikingInstallFailureHelp(installCommand, commandOutput);
+      throw new Error(
+        `${formatShellCommand(installCommand.executable, installCommand.args)} exited with ${result.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>");
+async function runInstallCommand(command2, env = {}) {
+  return new Promise((resolvePromise) => {
+    let stdout2 = "";
+    let stderr = "";
+    let settled = false;
+    const child = (0, import_node_child_process4.spawn)(command2.executable, command2.args, {
+      env: Object.keys(env).length === 0 ? process.env : { ...process.env, ...env },
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (chunk) => {
+      const text = String(chunk);
+      import_node_process4.stdout.write(text);
+      stdout2 = appendInstallOutputTail(stdout2, text);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = String(chunk);
+      import_node_process4.stderr.write(text);
+      stderr = appendInstallOutputTail(stderr, text);
+    });
+    child.on("error", (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      const message = errorMessage(err);
+      import_node_process4.stderr.write(`${message}
+`);
+      resolvePromise({ exitCode: 1, stderr: appendInstallOutputTail(stderr, message), stdout: stdout2 });
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolvePromise({ exitCode: code ?? 1, stderr, stdout: stdout2 });
+    });
+  });
+}
+function appendInstallOutputTail(current, chunk) {
+  const next = `${current}${chunk}`;
+  return next.length <= INSTALL_OUTPUT_TAIL_CHARS ? next : next.slice(next.length - INSTALL_OUTPUT_TAIL_CHARS);
+}
+function printOpenVikingInstallFailureHelp(failedCommand, commandOutput) {
+  for (const line of openVikingInstallFailureHelpLines(failedCommand, commandOutput)) {
+    console.error(line);
+  }
+}
+function openVikingInstallFailureHelpLines(failedCommand, commandOutput = "") {
+  if (isLlamaWheelArchiveExtractionFailure(commandOutput)) {
+    return [
+      "",
+      "OpenViking install did not complete.",
+      "The prebuilt llama-cpp-python wheel failed ZIP archive validation. Threadnote only falls back to a source build automatically when the failed command came from a prebuilt wheel index."
+    ];
+  }
+  const lines = [
+    "",
+    "OpenViking install did not complete.",
+    "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.",
+    "The package-manager output above contains the underlying build or download error."
+  ];
   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"
+      lines.push(
+        "If uv could not fetch managed CPython, Threadnote cannot complete the local install until that Python download is available."
       );
     }
-    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"');
   }
+  return lines;
+}
+function isLlamaWheelArchiveExtractionFailure(output2) {
+  const normalized = output2.toLowerCase();
+  return (normalized.includes("llama-cpp-python") || normalized.includes("llama_cpp_python")) && (normalized.includes("failed to extract archive") || normalized.includes("zip file contains trailing contents after the end-of-central-directory record"));
+}
+function openVikingSourceBuildRetryForArchiveFailure(failedCommand, commandOutput) {
+  if (!isLlamaWheelArchiveExtractionFailure(commandOutput)) {
+    return void 0;
+  }
+  const command2 = withoutExtraIndexUrl(failedCommand);
+  if (!command2) {
+    return void 0;
+  }
+  return { command: command2, env: sourceBuildEnvironment(failedCommand) };
+}
+function withoutExtraIndexUrl(command2) {
+  const args = [];
+  let changed = false;
+  for (let index = 0; index < command2.args.length; index += 1) {
+    const arg = command2.args[index];
+    const next = command2.args[index + 1];
+    if (arg === "--extra-index-url" && next !== void 0) {
+      changed = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--pip-args" && next?.includes("--extra-index-url") === true) {
+      changed = true;
+      index += 1;
+      continue;
+    }
+    args.push(arg);
+  }
+  return changed ? { ...command2, args } : void 0;
+}
+function formatInstallCommand(command2, env = {}) {
+  return [...formatEnvironmentAssignments(env), formatShellCommand(command2.executable, command2.args)].join(" ");
+}
+function formatEnvironmentAssignments(env) {
+  return Object.entries(env).map(
+    ([key, value]) => key === "CMAKE_ARGS" ? `${key}="${value.replaceAll('"', '\\"')}"` : `${key}=${shellQuote(value)}`
+  );
+}
+function sourceBuildEnvironment(command2) {
+  const env = {};
+  if (extraIndexUrl(command2)?.replace(/\/+$/, "").toLowerCase().endsWith("/metal") === true) {
+    env.CMAKE_ARGS = "-DGGML_METAL=on";
+  }
+  env.CMAKE_BUILD_PARALLEL_LEVEL = "2";
+  return env;
+}
+function extraIndexUrl(command2) {
+  for (let index = 0; index < command2.args.length; index += 1) {
+    const arg = command2.args[index];
+    if (arg === "--extra-index-url") {
+      return command2.args[index + 1];
+    }
+    if (arg === "--pip-args") {
+      const match = command2.args[index + 1]?.match(/(?:^|\s)--extra-index-url\s+(\S+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
 }
 async function offerToInstallUv() {
   if (import_node_process4.stdin.isTTY !== true || import_node_process4.stdout.isTTY !== true) {
@@ -15009,199 +15147,6 @@ function parsePackageManager(value) {
   throw new Error(`Invalid package manager: ${value}`);
 }
 
-// src/semantic_queue_repair.ts
-var import_node_fs8 = require("node:fs");
-var import_promises14 = require("node:fs/promises");
-var import_node_os7 = require("node:os");
-var import_node_path15 = require("node:path");
-var HOTFIX_MARKER = "THREADNOTE-HOTFIX-2734";
-var ENV_OVERRIDE = "THREADNOTE_OPENVIKING_SEMANTIC_PROCESSOR";
-function patchSemanticProcessorSource(source) {
-  if (source.includes(HOTFIX_MARKER)) {
-    return { status: "already-fixed" };
-  }
-  const lines = source.split("\n");
-  const defIndex = lines.findIndex((line) => /^\s*async def _process_memory_directory\b/.test(line));
-  if (defIndex < 0) {
-    return { status: "no-anchor" };
-  }
-  const lsPattern = /^(\s+)entries = await viking_fs\.ls\(dir_uri\b/;
-  let lsIndex = -1;
-  let lsIndent = "";
-  for (let i = defIndex + 1; i < lines.length; i += 1) {
-    const match = lsPattern.exec(lines[i]);
-    if (match) {
-      lsIndex = i;
-      lsIndent = match[1];
-      break;
-    }
-    if (/^\s*async def \w/.test(lines[i])) {
-      break;
-    }
-  }
-  if (lsIndex < 0) {
-    return { status: "no-anchor" };
-  }
-  if (lines.slice(defIndex, lsIndex).some((line) => line.includes("viking_fs.stat(dir_uri"))) {
-    return { status: "already-fixed" };
-  }
-  let tryIndex = -1;
-  let base = "";
-  for (let j = lsIndex - 1; j > defIndex; j -= 1) {
-    const text = lines[j];
-    if (text.trim() === "" || text.trimStart().startsWith("#")) {
-      continue;
-    }
-    const match = /^(\s*)try:\s*$/.exec(text);
-    if (match && match[1].length < lsIndent.length) {
-      tryIndex = j;
-      base = match[1];
-    }
-    break;
-  }
-  if (tryIndex < 0) {
-    return { status: "no-anchor" };
-  }
-  const unit = " ".repeat(lsIndent.length - base.length);
-  const at = (level, text) => `${base}${unit.repeat(level)}${text}`;
-  const guard = [
-    at(0, `# ${HOTFIX_MARKER}: skip non-directory / missing memory URIs so a memory file`),
-    at(0, "# reindexed with mode=semantic_and_vectors cannot poison the semantic queue."),
-    at(0, "# Temporary local hot-fix; superseded once OpenViking ships upstream PR #2735."),
-    at(0, "try:"),
-    at(1, "_tn_dir_stat = await viking_fs.stat(dir_uri, ctx=ctx)"),
-    at(0, "except Exception as _tn_err:"),
-    at(1, 'if isinstance(_tn_err, FileNotFoundError) or "not found" in str(_tn_err).lower():'),
-    at(2, "_mark_done()"),
-    at(2, "return"),
-    at(1, "_tn_dir_stat = None"),
-    at(0, 'if _tn_dir_stat is not None and not _tn_dir_stat.get("isDir", _tn_dir_stat.get("is_dir", False)):'),
-    at(1, "_mark_done()"),
-    at(1, "return")
-  ];
-  const patched = [...lines.slice(0, tryIndex), ...guard, ...lines.slice(tryIndex)].join("\n");
-  return { status: "patched", source: patched };
-}
-async function semanticProcessorCandidates(root) {
-  const lib = (0, import_node_path15.join)(root, "lib");
-  if (!(0, import_node_fs8.existsSync)(lib)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await (0, import_promises14.readdir)(lib);
-  } catch {
-    return [];
-  }
-  return entries.filter((name) => name.startsWith("python")).map((name) => (0, import_node_path15.join)(lib, name, "site-packages", "openviking", "storage", "queuefs", "semantic_processor.py"));
-}
-async function locateSemanticProcessorPath() {
-  const override = process.env[ENV_OVERRIDE]?.trim();
-  if (override) {
-    const resolved = expandPath(override);
-    if ((0, import_node_fs8.existsSync)(resolved)) {
-      return resolved;
-    }
-  }
-  const roots = [];
-  const server = await findOpenVikingServer();
-  if (server) {
-    roots.push((0, import_node_path15.dirname)((0, import_node_path15.dirname)(server)));
-  }
-  roots.push((0, import_node_path15.join)((0, import_node_os7.homedir)(), ".local", "share", "uv", "tools", "openviking"));
-  roots.push((0, import_node_path15.join)((0, import_node_os7.homedir)(), ".local", "pipx", "venvs", "openviking"));
-  for (const root of roots) {
-    for (const candidate of await semanticProcessorCandidates(root)) {
-      if ((0, import_node_fs8.existsSync)(candidate)) {
-        return candidate;
-      }
-    }
-  }
-  if (server) {
-    const venvPython = (0, import_node_path15.join)((0, import_node_path15.dirname)(server), process.platform === "win32" ? "python.exe" : "python3");
-    if ((0, import_node_fs8.existsSync)(venvPython)) {
-      const result = await runCommand(
-        venvPython,
-        [
-          "-c",
-          'import openviking, os; print(os.path.join(os.path.dirname(openviking.__file__), "storage", "queuefs", "semantic_processor.py"))'
-        ],
-        { allowFailure: true }
-      );
-      const path2 = result.stdout.trim();
-      if (result.exitCode === 0 && path2 && (0, import_node_fs8.existsSync)(path2)) {
-        return path2;
-      }
-    }
-  }
-  return void 0;
-}
-async function assertPatchedSourceCompiles(source) {
-  const python = await findExecutable(["python3", "python"]);
-  if (!python) {
-    console.warn("WARN python3 not found; skipping compile validation of the patched OpenViking source.");
-    return;
-  }
-  const dir = await (0, import_promises14.mkdtemp)((0, import_node_path15.join)((0, import_node_os7.tmpdir)(), "threadnote-ov-patch-"));
-  const file = (0, import_node_path15.join)(dir, "semantic_processor_patched.py");
-  try {
-    await (0, import_promises14.writeFile)(file, source, "utf8");
-    const result = await runCommand(python, ["-m", "py_compile", file], { allowFailure: true });
-    if (result.exitCode !== 0) {
-      throw new Error(`patched OpenViking source failed to compile: ${result.stderr.trim() || result.stdout.trim()}`);
-    }
-  } finally {
-    await (0, import_promises14.rm)(dir, { force: true, recursive: true });
-  }
-}
-async function runRepairSemanticQueue(config, options) {
-  const apply = options.apply === true && options.dryRun !== true;
-  const path2 = await locateSemanticProcessorPath();
-  if (!path2) {
-    console.error(
-      `Could not locate the installed OpenViking semantic_processor.py. Set ${ENV_OVERRIDE}=/path/to/openviking/storage/queuefs/semantic_processor.py and retry.`
-    );
-    process.exitCode = 1;
-    return;
-  }
-  console.log(`OpenViking semantic processor: ${path2}`);
-  let original;
-  try {
-    original = await (0, import_promises14.readFile)(path2, "utf8");
-  } catch (err) {
-    console.error(`Could not read ${path2}: ${errorMessage(err)}`);
-    process.exitCode = 1;
-    return;
-  }
-  const result = patchSemanticProcessorSource(original);
-  if (result.status === "already-fixed") {
-    console.log("OpenViking already guards non-directory memory URIs (#2734/#2735); nothing to patch.");
-    return;
-  }
-  if (result.status === "no-anchor") {
-    console.warn(
-      "WARN Could not find the _process_memory_directory ls(dir_uri) anchor; this OpenViking layout is unexpected, so no changes were made."
-    );
-    return;
-  }
-  if (!apply) {
-    console.log("Dry run: would patch OpenViking to skip non-directory/missing memory URIs, then restart the server.");
-    console.log("Re-run with --apply to perform it.");
-    return;
-  }
-  await assertPatchedSourceCompiles(result.source);
-  const backup = `${path2}.threadnote-bak`;
-  if (!(0, import_node_fs8.existsSync)(backup)) {
-    await (0, import_promises14.copyFile)(path2, backup);
-  }
-  await (0, import_promises14.writeFile)(path2, result.source, "utf8");
-  console.log(`Patched OpenViking semantic processor (backup: ${backup}).`);
-  console.log("Restarting the OpenViking server so the patch loads and any stuck message drains...");
-  await runStop(config, {});
-  await runStart(config, {});
-  console.log("Done. A stuck semantic message drains on the next dequeue; verify with: ov observer queue");
-}
-
 // src/version_command.ts
 async function runVersion(config, options) {
   const currentVersion = await currentPackageVersion();
@@ -15245,9 +15190,9 @@ function printWhatsNew(whatsNew) {
 // src/manager.ts
 var import_node_http2 = require("node:http");
 var import_node_crypto2 = require("node:crypto");
-var import_promises15 = require("node:fs/promises");
-var import_node_os8 = require("node:os");
-var import_node_path16 = require("node:path");
+var import_promises14 = require("node:fs/promises");
+var import_node_os7 = require("node:os");
+var import_node_path15 = require("node:path");
 var STATIC_FILES = {
   "/": { contentType: "text/html; charset=utf-8", path: "index.html" },
   "/index.html": { contentType: "text/html; charset=utf-8", path: "index.html" },
@@ -15318,18 +15263,18 @@ async function readManagedMemory(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only read current-user memory URIs: ${uri}`);
   }
-  const [content, pathStat] = await Promise.all([(0, import_promises15.readFile)(path2, "utf8"), (0, import_promises15.stat)(path2)]);
-  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2).split(import_node_path16.sep).join("/");
+  const [content, pathStat] = await Promise.all([(0, import_promises14.readFile)(path2, "utf8"), (0, import_promises14.stat)(path2)]);
+  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2).split(import_node_path15.sep).join("/");
   const record = parseMemoryDocument(uri, content);
   return {
     content,
     node: {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
-      isSystem: isSystemMemoryName(path2.split(import_node_path16.sep).at(-1) ?? ""),
+      isSystem: isSystemMemoryName(path2.split(import_node_path15.sep).at(-1) ?? ""),
       metadata: record?.metadata,
       modTime: pathStat.mtime.toISOString(),
-      name: path2.split(import_node_path16.sep).at(-1) ?? uri,
+      name: path2.split(import_node_path15.sep).at(-1) ?? uri,
       relativePath,
       sharedTeam: sharedTeamNameForUri(config, uri),
       size: pathStat.size,
@@ -15617,7 +15562,7 @@ async function handleRequest(context, request, response) {
 }
 async function serveStatic(context, url, response) {
   const file = STATIC_FILES[url.pathname] ?? STATIC_FILES["/"];
-  const content = await (0, import_promises15.readFile)((0, import_node_path16.join)(toolRoot(), file.root ?? "manager", file.path));
+  const content = await (0, import_promises14.readFile)((0, import_node_path15.join)(toolRoot(), file.root ?? "manager", file.path));
   const headers = { "content-type": file.contentType };
   if (file.root !== "docs") {
     headers["cache-control"] = "no-store";
@@ -15626,11 +15571,11 @@ async function serveStatic(context, url, response) {
   response.end(content);
 }
 async function readTree(config, path2, uri, relativePath, options = {}) {
-  const pathStat = await (0, import_promises15.stat)(path2);
+  const pathStat = await (0, import_promises14.stat)(path2);
   const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : options.rootName ?? "memories";
   const isDir = pathStat.isDirectory();
   if (!isDir) {
-    const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises15.readFile)(path2, "utf8").catch(() => ""));
+    const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises14.readFile)(path2, "utf8").catch(() => ""));
     return {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
@@ -15644,13 +15589,13 @@ async function readTree(config, path2, uri, relativePath, options = {}) {
       uri
     };
   }
-  const entries = await (0, import_promises15.readdir)(path2, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(path2, { withFileTypes: true });
   const children = await Promise.all(
     entries.sort(
       (left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name)
     ).map((entry) => {
       const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-      return readTree(config, (0, import_node_path16.join)(path2, entry.name), `${uri}/${entry.name}`, childRelative, options);
+      return readTree(config, (0, import_node_path15.join)(path2, entry.name), `${uri}/${entry.name}`, childRelative, options);
     })
   );
   return {
@@ -15824,27 +15769,27 @@ async function removeManagedFolder(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only remove current-user memory folders: ${uri}`);
   }
-  const pathStat = await (0, import_promises15.stat)(path2);
+  const pathStat = await (0, import_promises14.stat)(path2);
   if (!pathStat.isDirectory()) {
     throw new Error(`Not a folder: ${uri}`);
   }
-  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path16.sep).includes("..")) {
+  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path15.sep).includes("..")) {
     throw new Error("Refusing to remove a folder outside the memories tree.");
   }
   const fileUris = await fileUrisUnderFolder(config, path2);
   for (const fileUri of fileUris) {
     await runForget(config, fileUri, {});
   }
-  await (0, import_promises15.rm)(path2, { force: true, recursive: true });
+  await (0, import_promises14.rm)(path2, { force: true, recursive: true });
   console.log(`Removed folder: ${uri}`);
   console.log(`Forgot ${fileUris.length} file${fileUris.length === 1 ? "" : "s"}.`);
 }
 async function fileUrisUnderFolder(config, folderPath) {
-  const entries = await (0, import_promises15.readdir)(folderPath, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(folderPath, { withFileTypes: true });
   const uris = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const path2 = (0, import_node_path16.join)(folderPath, entry.name);
+    const path2 = (0, import_node_path15.join)(folderPath, entry.name);
     if (entry.isDirectory()) {
       uris.push(...await fileUrisUnderFolder(config, path2));
     } else if (entry.isFile()) {
@@ -15942,11 +15887,11 @@ async function runConsolidationAgent(agent, sources) {
     throw new Error(`${agent} executable was not found.`);
   }
   const prompt = consolidationPrompt(sources);
-  const stagingDir = await (0, import_promises15.mkdtemp)((0, import_node_path16.join)((0, import_node_os8.tmpdir)(), "threadnote-consolidate-"));
-  const promptPath = (0, import_node_path16.join)(stagingDir, "prompt.txt");
+  const stagingDir = await (0, import_promises14.mkdtemp)((0, import_node_path15.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
+  const promptPath = (0, import_node_path15.join)(stagingDir, "prompt.txt");
   try {
-    await (0, import_promises15.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
-    await (0, import_promises15.chmod)(promptPath, 384);
+    await (0, import_promises14.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
+    await (0, import_promises14.chmod)(promptPath, 384);
     const script = consolidationAgentScript(agent, executable);
     const result = await runCommand("sh", ["-lc", script, "threadnote-consolidate", promptPath], {
       allowFailure: true,
@@ -15962,7 +15907,7 @@ async function runConsolidationAgent(agent, sources) {
     }
     return draft;
   } finally {
-    await (0, import_promises15.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises14.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 function consolidationAgentScript(agent, executable) {
@@ -16100,10 +16045,10 @@ function memoryDirectoryUri2(config, kind, status, projectSegment) {
   }
 }
 function localMemoriesRoot(config) {
-  return (0, import_node_path16.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
+  return (0, import_node_path15.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
 }
 function localResourcesRoot(config) {
-  return (0, import_node_path16.join)(config.agentContextHome, "data", "viking", config.account, "resources");
+  return (0, import_node_path15.join)(config.agentContextHome, "data", "viking", config.account, "resources");
 }
 function localPathForMemoryUri(config, uri) {
   const prefix = `viking://user/${uriSegment(config.user)}/memories`;
@@ -16115,17 +16060,17 @@ function localPathForMemoryUri(config, uri) {
   if (segments.some((segment) => segment === "." || segment === "..")) {
     return void 0;
   }
-  return (0, import_node_path16.join)(localMemoriesRoot(config), ...segments);
+  return (0, import_node_path15.join)(localMemoriesRoot(config), ...segments);
 }
 function isMissingPathError(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 function localPathToMemoryUri(config, path2) {
-  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path16.sep).includes("..")) {
+  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path15.sep).includes("..")) {
     throw new Error(`Path is outside the memories tree: ${path2}`);
   }
-  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path16.sep).join("/")}`;
+  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path15.sep).join("/")}`;
 }
 async function ensurePersonalDirectoryChain2(config, ov, directoryUri) {
   const prefix = "viking://";
@@ -16365,9 +16310,6 @@ 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("repair-semantic-queue").description("Patch the installed OpenViking to drain/avoid the semantic-queue poison loop (#2734)").option("--apply", "Apply the patch and restart the server; without this, prints a dry run").option("--dry-run", "Print what would change without patching or restarting").action(async (options) => {
-    await runRepairSemanticQueue(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 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);
   });

package/docs/index.html

@@ -1147,7 +1147,7 @@
 <span class="out">--user`, which fails on PEP 668 setups.</span>
 <span class="out">Install uv now? [Y/n] </span><span class="out-strong">Y</span>
 <span class="out">Installing uv via Homebrew…</span>
-<span class="out-strong">OK   openviking 0.4.4 ready · server healthy</span></pre>
+<span class="out-strong">OK   openviking 0.4.5 ready · server healthy</span></pre>
               </div>
               <p class="muted" style="margin-top: 0.75rem; font-size: 0.9rem">
                 Or manually: <code>npm install -g threadnote && threadnote install</code>. On a fresh macOS / modern
@@ -1651,7 +1651,7 @@ threadnote doctor --dry-run</code></pre>
           </div>
 
           <p class="colophon">
-            threadnote · AGPL-3.0-or-later · built on OpenViking 0.4.4 · use <span class="kbd">↑</span>
+            threadnote · AGPL-3.0-or-later · built on OpenViking 0.4.5 · use <span class="kbd">↑</span>
             <span class="kbd">↓</span> / <span class="kbd">j</span> <span class="kbd">k</span> to navigate
           </p>
         </div>

package/docs/troubleshooting.md

@@ -102,28 +102,26 @@ Symptom: agents hang or `remember`/`handoff` get very slow, and `~/.openviking/l
 RuntimeError: Failed to list memory directory viking://user/.../memories/.../<name>.md: Directory not found
 ```
 
-A memory _file_ got enqueued for directory-level semantic processing; OpenViking's `_process_memory_directory` lists
-it, fails, and the message re-enqueues forever. The entry is AGFS-persisted, so it survives a server restart. Check the
-queue — a non-zero `Errors`/`Requeued` on the `Semantic` row is the signature:
+A memory _file_ got enqueued for directory-level semantic processing; older OpenViking releases listed it as a
+directory, failed, and re-enqueued the message forever. The entry is AGFS-persisted, so it survives a server restart.
+Check the queue — a non-zero `Errors`/`Requeued` on the `Semantic` row is the signature:
 
 ```bash
 ov observer queue
 ```
 
-Fix it by patching the installed OpenViking and restarting the server:
+This is fixed upstream in OpenViking 0.4.5. Update Threadnote so it upgrades the pinned OpenViking install and restarts
+the server:
 
 ```bash
-threadnote repair-semantic-queue --apply
+threadnote update
 ```
 
-It skips non-directory/missing memory URIs (OpenViking PR #2735), keeps a `.threadnote-bak`, compile-checks the patched
-file before writing, and is a no-op once the installed OpenViking already includes the fix. This is a **temporary local
-patch** — `threadnote update` also offers it as a post-update step, and it is superseded automatically once Threadnote
-pins an OpenViking release containing the fix. To revert manually:
+If Threadnote is already current but OpenViking is still older than 0.4.5, force a reinstall of the pinned OpenViking
+tool:
 
 ```bash
-mv <printed-path>.threadnote-bak <printed-path>
-threadnote stop && threadnote start
+threadnote install --force
 ```
 
 ## Port Already In Use

package/package.json

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