threadnote 0.7.1 → 0.7.3

package/dist/mcp_server.cjs

@@ -34108,10 +34108,8 @@ async function runShareSyncQuiet(config2, state, options) {
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const pendingChanges = state.pendingReindexes.get(team.name);
-  if (pendingChanges) {
-    await applyChangesToOpenViking(config2, team.config, pendingChanges, { quiet: true });
-    state.pendingReindexes.delete(team.name);
-    await writePendingReindexes(config2, state);
+  if (pendingChanges && pendingChanges.length > 0) {
+    await applyAndPersistChanges(config2, team.config, state, pendingChanges, { quiet: true });
   }
   if (await hasUncommittedChanges(worktree)) {
     return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
@@ -34139,11 +34137,9 @@ async function runShareSyncQuiet(config2, state, options) {
   if (beforeRev && afterRev && beforeRev !== afterRev) {
     const changes = await listChangedFiles(worktree, beforeRev, afterRev);
     if (changes.length > 0) {
-      state.pendingReindexes.set(team.name, changes);
-      await writePendingReindexes(config2, state);
-      await applyChangesToOpenViking(config2, team.config, changes, { quiet: true });
-      state.pendingReindexes.delete(team.name);
-      await writePendingReindexes(config2, state);
+      const stillPending = state.pendingReindexes.get(team.name) ?? [];
+      const combined = mergeChanges(stillPending, changes);
+      await applyAndPersistChanges(config2, team.config, state, combined, { quiet: true });
     }
   }
   return void 0;
@@ -34339,8 +34335,9 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, o
     await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
   }
 }
+var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, options = {}) {
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   const existedBeforeWrite = await vikingResourceExists(ov, config2, uri);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config2, uri);
@@ -34384,6 +34381,7 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, opt
     }
     if (isResourceBusyFailure(result.stderr, result.stdout)) {
       await waitForOvQueue(ov, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
     } else {
       await sleep(1e3 * (attempt + 1));
     }
@@ -34461,7 +34459,7 @@ async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
     }
     return;
   }
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -34475,6 +34473,7 @@ async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
     }
     if (isResourceBusyFailure(result.stderr, result.stdout)) {
       await waitForOvQueue(ov, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
     } else {
       await sleep(1e3 * (attempt + 1));
     }
@@ -34531,6 +34530,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
 }
 async function applyChangesToOpenViking(config2, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
+  const failed = [];
   for (const change of changes) {
     if (!change.relativePath.endsWith(".md")) {
       continue;
@@ -34540,24 +34540,57 @@ async function applyChangesToOpenViking(config2, team, changes, options = {}) {
       continue;
     }
     const uri = workfileToVikingUri(config2, team, change.path);
-    if (change.status === "removed") {
-      await removeMemoryUri(config2, ov, uri, false, options);
-      continue;
-    }
-    if (!await isFile(change.path)) {
-      continue;
-    }
-    const ovHasResource = await vikingResourceExists(ov, config2, uri);
-    if (ovHasResource) {
-      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+    try {
+      if (change.status === "removed") {
+        await removeMemoryUri(config2, ov, uri, false, options);
+        continue;
+      }
+      if (!await isFile(change.path)) {
+        continue;
+      }
+      const ovHasResource = await vikingResourceExists(ov, config2, uri);
+      if (ovHasResource) {
+        const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+        if (options.quiet !== true) {
+          console.warn(`share sync: ${uri}: ${reason}.`);
+        }
+      }
+      await ensureSharedDirectoryChain(config2, ov, uri, false, options);
+      const writeMode = ovHasResource ? "replace" : "create";
+      await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
-        console.warn(`share sync: ${uri}: ${reason}.`);
+        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
       }
+      failed.push(change);
+    }
+  }
+  return { failed };
+}
+function mergeChanges(...lists) {
+  const map3 = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const change of list) {
+      map3.set(change.relativePath, change);
     }
-    await ensureSharedDirectoryChain(config2, ov, uri, false, options);
-    const writeMode = ovHasResource ? "replace" : "create";
-    await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
   }
+  return [...map3.values()];
+}
+async function applyAndPersistChanges(config2, team, state, changes, options = {}) {
+  if (changes.length === 0) {
+    return { failed: [] };
+  }
+  state.pendingReindexes.set(team.name, changes);
+  await writePendingReindexes(config2, state);
+  const result = await applyChangesToOpenViking(config2, team, changes, options);
+  if (result.failed.length > 0) {
+    state.pendingReindexes.set(team.name, result.failed);
+  } else {
+    state.pendingReindexes.delete(team.name);
+  }
+  await writePendingReindexes(config2, state);
+  return result;
 }
 
 // src/mcp_server.ts

package/dist/threadnote.cjs

@@ -3472,7 +3472,7 @@ var {
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.3.12";
+var DEFAULT_OPENVIKING_VERSION = "0.3.21";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 var OPENVIKING_PACKAGE_NAME = "openviking[local-embed]";
@@ -3747,6 +3747,38 @@ async function sleep(ms) {
     setTimeout(resolvePromise, ms);
   });
 }
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = left.numbers[index] - right.numbers[index];
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  if (left.prerelease === right.prerelease) {
+    return 0;
+  }
+  if (left.prerelease === void 0) {
+    return 1;
+  }
+  if (right.prerelease === void 0) {
+    return -1;
+  }
+  return left.prerelease.localeCompare(right.prerelease);
+}
+function parseVersion(version) {
+  const normalized = version.trim().replace(/^v/, "");
+  const [core2, prerelease] = normalized.split("-", 2);
+  const parts = core2.split(".").map((part) => Number(part));
+  return {
+    numbers: [safeVersionNumber(parts[0]), safeVersionNumber(parts[1]), safeVersionNumber(parts[2])],
+    prerelease
+  };
+}
+function safeVersionNumber(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
 async function readHttpStatus(url, timeoutMs) {
   return new Promise((resolvePromise) => {
     const request = (0, import_node_http.get)(url, (response) => {
@@ -7583,12 +7615,24 @@ Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or
     );
   }
   const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
-  if (!dryRun && beforeRev && afterRev && beforeRev !== afterRev) {
-    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
-    await applyChangesToOpenViking(config, team.config, changes);
-    console.log(`Reindexed ${changes.length} file change(s) into OpenViking.`);
-  } else if (!dryRun) {
-    console.log("No upstream changes to reindex.");
+  if (!dryRun) {
+    const state = autoShareState(config);
+    await loadPendingReindexes(config, state);
+    const previouslyPending = state.pendingReindexes.get(team.name) ?? [];
+    const newChanges = beforeRev && afterRev && beforeRev !== afterRev ? await listChangedFiles(worktree, beforeRev, afterRev) : [];
+    const combined = mergeChanges(previouslyPending, newChanges);
+    if (combined.length === 0) {
+      console.log("No upstream changes to reindex.");
+    } else {
+      const result = await applyAndPersistChanges(config, team.config, state, combined);
+      const succeeded = combined.length - result.failed.length;
+      console.log(`Reindexed ${succeeded} file change(s) into OpenViking.`);
+      if (result.failed.length > 0) {
+        console.warn(
+          `share sync: ${result.failed.length} file(s) could not be ingested on this run; they are persisted and will be retried on the next sync or agent recall/read.`
+        );
+      }
+    }
   }
   if (options.push !== false) {
     await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
@@ -7599,10 +7643,8 @@ async function runShareSyncQuiet(config, state, options) {
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const pendingChanges = state.pendingReindexes.get(team.name);
-  if (pendingChanges) {
-    await applyChangesToOpenViking(config, team.config, pendingChanges, { quiet: true });
-    state.pendingReindexes.delete(team.name);
-    await writePendingReindexes(config, state);
+  if (pendingChanges && pendingChanges.length > 0) {
+    await applyAndPersistChanges(config, team.config, state, pendingChanges, { quiet: true });
   }
   if (await hasUncommittedChanges(worktree)) {
     return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
@@ -7630,11 +7672,9 @@ async function runShareSyncQuiet(config, state, options) {
   if (beforeRev && afterRev && beforeRev !== afterRev) {
     const changes = await listChangedFiles(worktree, beforeRev, afterRev);
     if (changes.length > 0) {
-      state.pendingReindexes.set(team.name, changes);
-      await writePendingReindexes(config, state);
-      await applyChangesToOpenViking(config, team.config, changes, { quiet: true });
-      state.pendingReindexes.delete(team.name);
-      await writePendingReindexes(config, state);
+      const stillPending = state.pendingReindexes.get(team.name) ?? [];
+      const combined = mergeChanges(stillPending, changes);
+      await applyAndPersistChanges(config, team.config, state, combined, { quiet: true });
     }
   }
   return void 0;
@@ -8074,8 +8114,9 @@ async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun, op
     await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
   }
 }
+var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, options = {}) {
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   const existedBeforeWrite = await vikingResourceExists(ov, config, uri);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config, uri);
@@ -8119,6 +8160,7 @@ async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, opti
     }
     if (isResourceBusyFailure(result.stderr, result.stdout)) {
       await waitForOvQueue(ov, config, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
     } else {
       await sleep(1e3 * (attempt + 1));
     }
@@ -8196,7 +8238,7 @@ async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
     }
     return;
   }
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -8210,6 +8252,7 @@ async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
     }
     if (isResourceBusyFailure(result.stderr, result.stdout)) {
       await waitForOvQueue(ov, config, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
     } else {
       await sleep(1e3 * (attempt + 1));
     }
@@ -8266,6 +8309,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
 }
 async function applyChangesToOpenViking(config, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
+  const failed = [];
   for (const change of changes) {
     if (!change.relativePath.endsWith(".md")) {
       continue;
@@ -8275,24 +8319,57 @@ async function applyChangesToOpenViking(config, team, changes, options = {}) {
       continue;
     }
     const uri = workfileToVikingUri(config, team, change.path);
-    if (change.status === "removed") {
-      await removeMemoryUri(config, ov, uri, false, options);
-      continue;
-    }
-    if (!await isFile(change.path)) {
-      continue;
-    }
-    const ovHasResource = await vikingResourceExists(ov, config, uri);
-    if (ovHasResource) {
-      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+    try {
+      if (change.status === "removed") {
+        await removeMemoryUri(config, ov, uri, false, options);
+        continue;
+      }
+      if (!await isFile(change.path)) {
+        continue;
+      }
+      const ovHasResource = await vikingResourceExists(ov, config, uri);
+      if (ovHasResource) {
+        const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+        if (options.quiet !== true) {
+          console.warn(`share sync: ${uri}: ${reason}.`);
+        }
+      }
+      await ensureSharedDirectoryChain(config, ov, uri, false, options);
+      const writeMode = ovHasResource ? "replace" : "create";
+      await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
-        console.warn(`share sync: ${uri}: ${reason}.`);
+        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
       }
+      failed.push(change);
+    }
+  }
+  return { failed };
+}
+function mergeChanges(...lists) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const change of list) {
+      map2.set(change.relativePath, change);
     }
-    await ensureSharedDirectoryChain(config, ov, uri, false, options);
-    const writeMode = ovHasResource ? "replace" : "create";
-    await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
   }
+  return [...map2.values()];
+}
+async function applyAndPersistChanges(config, team, state, changes, options = {}) {
+  if (changes.length === 0) {
+    return { failed: [] };
+  }
+  state.pendingReindexes.set(team.name, changes);
+  await writePendingReindexes(config, state);
+  const result = await applyChangesToOpenViking(config, team, changes, options);
+  if (result.failed.length > 0) {
+    state.pendingReindexes.set(team.name, result.failed);
+  } else {
+    state.pendingReindexes.delete(team.name);
+  }
+  await writePendingReindexes(config, state);
+  return result;
 }
 
 // src/memory.ts
@@ -9234,7 +9311,7 @@ async function checkForThreadnoteUpdate(args) {
   }
   const cached = await readUpdateCache(args.cachePath);
   if (cached && isCacheFresh(cached)) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+    return compareVersions2(args.currentVersion, cached.latestVersion);
   }
   const fresh = await fetchLatestVersion();
   if (fresh) {
@@ -9243,10 +9320,10 @@ async function checkForThreadnoteUpdate(args) {
       latestVersion: fresh,
       version: 1
     });
-    return compareVersions(args.currentVersion, fresh);
+    return compareVersions2(args.currentVersion, fresh);
   }
   if (cached) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+    return compareVersions2(args.currentVersion, cached.latestVersion);
   }
   return void 0;
 }
@@ -9264,7 +9341,7 @@ function spawnDetachedAutoUpdate() {
   } catch {
   }
 }
-function compareVersions(currentVersion, latestVersion) {
+function compareVersions2(currentVersion, latestVersion) {
   return {
     currentVersion,
     latestVersion,
@@ -9272,8 +9349,8 @@ function compareVersions(currentVersion, latestVersion) {
   };
 }
 function isNewerVersion(candidate, baseline) {
-  const candidateParts = parseVersion(candidate);
-  const baselineParts = parseVersion(baseline);
+  const candidateParts = parseVersion2(candidate);
+  const baselineParts = parseVersion2(baseline);
   for (let index = 0; index < 3; index += 1) {
     if (candidateParts[index] !== baselineParts[index]) {
       return candidateParts[index] > baselineParts[index];
@@ -9281,7 +9358,7 @@ function isNewerVersion(candidate, baseline) {
   }
   return false;
 }
-function parseVersion(value) {
+function parseVersion2(value) {
   const parts = value.split(".").map((part) => parseInt(part, 10));
   return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
 }
@@ -9999,7 +10076,7 @@ async function runUpdate(config, options) {
       console.log(`Update available. Run: threadnote update`);
     } else {
       console.log(
-        compareVersions2(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
+        compareVersions(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
       );
     }
     return;
@@ -10046,10 +10123,16 @@ async function runPostUpdate(config, options) {
   if (!options.fromVersion || !options.toVersion) {
     throw new Error("Provide --from-version and --to-version for post-update.");
   }
+  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  await ensurePinnedOpenVikingInstalled(config, {
+    dryRun: options.dryRun === true,
+    interactive,
+    yes: options.yes === true
+  });
   await runApplicablePostUpdateMigrations(config, {
     dryRun: options.dryRun === true,
     fromVersion: options.fromVersion,
-    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    interactive,
     markHandled: true,
     toVersion: options.toVersion,
     yes: options.yes === true
@@ -10057,6 +10140,8 @@ async function runPostUpdate(config, options) {
 }
 async function maybeRunPostUpdateAfterRepair(config, options) {
   const toVersion = await currentPackageVersion();
+  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  await ensurePinnedOpenVikingInstalled(config, { dryRun: options.dryRun, interactive, yes: false });
   const state = await readPostUpdateState(config);
   const migrations = await applicablePostUpdateMigrations(config, {
     fromVersion: "0.0.0",
@@ -10069,7 +10154,7 @@ async function maybeRunPostUpdateAfterRepair(config, options) {
   console.log("");
   console.log("Repair found package post-update migrations.");
   console.log("This also covers updates launched by older Threadnote versions that only knew how to run repair.");
-  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+  if (!interactive) {
     console.log(
       "This process is non-interactive, so Threadnote will print the manual migration command instead of prompting."
     );
@@ -10078,12 +10163,48 @@ async function maybeRunPostUpdateAfterRepair(config, options) {
   await runApplicablePostUpdateMigrations(config, {
     dryRun: options.dryRun,
     fromVersion: "0.0.0",
-    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    interactive,
     markHandled: true,
     toVersion,
     yes: false
   });
 }
+async function ensurePinnedOpenVikingInstalled(config, options) {
+  const ov = await findExecutable(["ov", "openviking"]);
+  if (!ov) {
+    return;
+  }
+  const installedVersion = await readOpenVikingCliVersion(ov);
+  if (!installedVersion) {
+    console.log(`Could not detect OpenViking CLI version via \`${ov} version\`; skipping pinned-version check.`);
+    return;
+  }
+  const pinned = config.openVikingVersion;
+  if (compareVersions(installedVersion, pinned) >= 0) {
+    return;
+  }
+  console.log("");
+  console.log(`OpenViking ${installedVersion} is older than the pinned version ${pinned}.`);
+  console.log(
+    "Upgrading picks up upstream fixes for share-sync reliability (reindex lock acquisition, ov wait timeout)."
+  );
+  const threadnoteCommand = currentThreadnoteCommand() ?? await findExecutable([NPM_PACKAGE_NAME]) ?? NPM_PACKAGE_NAME;
+  const installArgs = ["install", "--force", "--no-start"];
+  const accepted = options.dryRun || options.yes || options.interactive && await confirmPostUpdateMigration(`Upgrade OpenViking to ${pinned} now? [Y/n] `, true);
+  if (!accepted) {
+    console.log(`Skipped. Run manually later: ${formatMigrationCommand(threadnoteCommand, installArgs)}`);
+    return;
+  }
+  await maybeRun(options.dryRun, threadnoteCommand, installArgs);
+}
+async function readOpenVikingCliVersion(ov) {
+  const result = await runCommand(ov, ["version"], { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  const match = result.stdout.match(/^\s*CLI:\s*(\S+)/m);
+  return match ? match[1] : void 0;
+}
 async function getUpdateInfo(config, options) {
   const currentVersion = await currentPackageVersion();
   const cached = options.preferFresh ? void 0 : await readFreshCache(config, options.registry);
@@ -10093,7 +10214,7 @@ async function getUpdateInfo(config, options) {
   }
   return {
     currentVersion,
-    isUpdateAvailable: compareVersions2(currentVersion, latestVersion) < 0,
+    isUpdateAvailable: compareVersions(currentVersion, latestVersion) < 0,
     latestVersion,
     registry: options.registry
   };
@@ -10203,10 +10324,10 @@ async function applicablePostUpdateMigrations(config, options) {
     if (handled.has(migration.id)) {
       continue;
     }
-    if (compareVersions2(options.fromVersion, migration.introducedIn) >= 0) {
+    if (compareVersions(options.fromVersion, migration.introducedIn) >= 0) {
       continue;
     }
-    if (compareVersions2(migration.introducedIn, options.toVersion) > 0) {
+    if (compareVersions(migration.introducedIn, options.toVersion) > 0) {
       continue;
     }
     if (migration.requiresLegacyHandoffs === true && !await hasLegacyLifecycleHandoffCandidates(config)) {
@@ -10255,10 +10376,13 @@ function printPostUpdateMigration(migration) {
     console.log(`- ${line}`);
   }
 }
-async function confirmPostUpdateMigration(prompt) {
+async function confirmPostUpdateMigration(prompt, defaultYes = false) {
   const readline = (0, import_promises10.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
   try {
     const answer = (await readline.question(prompt)).trim().toLowerCase();
+    if (answer === "") {
+      return defaultYes;
+    }
     return answer === "y" || answer === "yes";
   } finally {
     readline.close();
@@ -10374,38 +10498,6 @@ function updateRegistry() {
 function isUpdateNotificationDisabled() {
   return process.env.CI !== void 0 || process.env.NO_UPDATE_NOTIFIER !== void 0 || process.env.THREADNOTE_NO_UPDATE_CHECK !== void 0;
 }
-function compareVersions2(currentVersion, latestVersion) {
-  const current = parseVersion2(currentVersion);
-  const latest = parseVersion2(latestVersion);
-  for (let index = 0; index < 3; index += 1) {
-    const difference = current.numbers[index] - latest.numbers[index];
-    if (difference !== 0) {
-      return difference;
-    }
-  }
-  if (current.prerelease === latest.prerelease) {
-    return 0;
-  }
-  if (current.prerelease === void 0) {
-    return 1;
-  }
-  if (latest.prerelease === void 0) {
-    return -1;
-  }
-  return current.prerelease.localeCompare(latest.prerelease);
-}
-function parseVersion2(version) {
-  const normalized = version.trim().replace(/^v/, "");
-  const [core2, prerelease] = normalized.split("-", 2);
-  const parts = core2.split(".").map((part) => Number(part));
-  return {
-    numbers: [safeVersionNumber(parts[0]), safeVersionNumber(parts[1]), safeVersionNumber(parts[2])],
-    prerelease
-  };
-}
-function safeVersionNumber(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
-}
 
 // src/lifecycle.ts
 async function runDoctor(config, options) {
@@ -10453,7 +10545,10 @@ async function runInstall(config, options) {
     console.log(`OpenViking server already installed: ${serverPath}`);
     const localEmbeddingMissing = await hasLocalEmbeddingDependency(serverPath) === false;
     const pythonSystemCertificatesMissing = await hasPythonSystemCertificatesPatch(serverPath) === false;
-    if (localEmbeddingMissing) {
+    if (options.force === true) {
+      console.log(`Reinstalling OpenViking at pinned version ${config.openVikingVersion} (--force).`);
+      await runInstallCommands(config, options.packageManager, true, dryRun);
+    } else if (localEmbeddingMissing) {
       const repairReasons = [];
       repairReasons.push("local embedding extra is missing");
       if (pythonSystemCertificatesMissing) {
@@ -11369,7 +11464,7 @@ async function main() {
     await runDoctor(config, options);
     await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
   });
-  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
+  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--force", "Reinstall OpenViking at the pinned version even if a working install is already present").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
     "--with-hooks",
     "Also install agent-side hooks (Claude PreCompact + SessionStart) for deterministic handoff snapshots and context preload"
   ).action(async (options) => {

package/package.json

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