threadnote 0.6.0 → 0.6.2

package/dist/threadnote.cjs

@@ -3522,8 +3522,8 @@ var DEFAULT_SEED_PATTERNS = [
 ];
 
 // src/hooks.ts
-var import_promises5 = require("node:fs/promises");
-var import_node_path5 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path7 = require("node:path");
 
 // src/mcp.ts
 var import_node_fs2 = require("node:fs");
@@ -7118,6 +7118,15 @@ function uriSegment(value) {
   const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized.length > 0 ? normalized : "unknown";
 }
+async function inferProjectFromQuery(manifestPath, query) {
+  try {
+    const manifest = await readSeedManifest(manifestPath);
+    const normalized = query.toLowerCase();
+    return manifest.projects.find((project) => normalized.includes(project.name.toLowerCase()));
+  } catch {
+    return void 0;
+  }
+}
 async function readSeedManifest(path) {
   const raw = await (0, import_promises3.readFile)(path, "utf8");
   const loaded = jsYaml.load(raw);
@@ -7388,11 +7397,32 @@ async function runRecall(config, options) {
     args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
   }
   await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  await augmentRecallWithSeededResources(config, ov, options, inferredUri);
   await printExactMemoryMatches(config, ov, options.query, {
     dryRun: options.dryRun === true,
     includeArchived: options.includeArchived === true
   });
 }
+async function augmentRecallWithSeededResources(config, ov, options, inferredUri) {
+  if (options.uri || options.inferScope === false) {
+    return;
+  }
+  const project = await inferProjectFromQuery(config.manifestPath, options.query);
+  if (!project) {
+    return;
+  }
+  const projectResourceUri = trimTrailingSlash(project.uri);
+  if (!projectResourceUri.startsWith("viking://") || projectResourceUri === inferredUri) {
+    return;
+  }
+  const args = ["search", options.query, "--uri", projectResourceUri];
+  if (options.nodeLimit) {
+    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  }
+  console.log(`
+Also searching seeded resources: ${projectResourceUri}`);
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+}
 async function runRead(config, uri, options) {
   assertVikingUri(uri);
   const ov = await openVikingCliForMode(options.dryRun === true);
@@ -7511,21 +7541,11 @@ async function runImportPack(config, options) {
   );
 }
 async function inferRecallUri(config, query) {
-  const normalizedQuery = query.toLowerCase();
-  if (/\bskills?\b/.test(normalizedQuery)) {
-    const project2 = await inferProjectFromQuery(config, normalizedQuery);
-    return project2 ? `viking://resources/agent-skills/repo-local-${uriSegment(project2.name)}` : "viking://resources/agent-skills";
-  }
-  const project = await inferProjectFromQuery(config, normalizedQuery);
-  return project ? trimTrailingSlash(project.uri) : void 0;
-}
-async function inferProjectFromQuery(config, normalizedQuery) {
-  try {
-    const manifest = await readSeedManifest(config.manifestPath);
-    return manifest.projects.find((project) => normalizedQuery.includes(project.name.toLowerCase()));
-  } catch (_err) {
+  if (!/\bskills?\b/.test(query.toLowerCase())) {
     return void 0;
   }
+  const project = await inferProjectFromQuery(config.manifestPath, query);
+  return project ? `viking://resources/agent-skills/repo-local-${uriSegment(project.name)}` : "viking://resources/agent-skills";
 }
 async function printExactMemoryMatches(config, ov, query, options) {
   const terms = exactRecallTerms(query);
@@ -7755,7 +7775,11 @@ function exactMemoryScopes(config, includeArchived) {
     `${userBase}/incidents/active`,
     `${userBase}/events`,
     `${userBase}/shared`,
-    `viking://agent/${uriSegment(config.agentId)}/memories`
+    `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;
 }
@@ -8109,6 +8133,128 @@ function formatBlock(value, emptyValue) {
   return trimmed.split("\n").map((line) => `- ${line}`).join("\n");
 }
 
+// src/update-check.ts
+var import_node_child_process2 = require("node:child_process");
+var import_promises5 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NPM_LATEST_URL = "https://registry.npmjs.org/threadnote/latest";
+var FETCH_TIMEOUT_MS = 3e3;
+async function checkForThreadnoteUpdate(args) {
+  if (args.currentVersion === "unknown") {
+    return void 0;
+  }
+  const cached = await readUpdateCache(args.cachePath);
+  if (cached && isCacheFresh(cached)) {
+    return compareVersions(args.currentVersion, cached.latestVersion);
+  }
+  const fresh = await fetchLatestVersion();
+  if (fresh) {
+    await writeUpdateCache(args.cachePath, {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      latestVersion: fresh,
+      version: 1
+    });
+    return compareVersions(args.currentVersion, fresh);
+  }
+  if (cached) {
+    return compareVersions(args.currentVersion, cached.latestVersion);
+  }
+  return void 0;
+}
+function spawnDetachedAutoUpdate() {
+  try {
+    const entry = process.argv[1];
+    if (typeof entry !== "string" || entry.length === 0) {
+      return;
+    }
+    const child = (0, import_node_child_process2.spawn)(process.execPath, [entry, "update", "--yes"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {
+  }
+}
+function compareVersions(currentVersion, latestVersion) {
+  return {
+    currentVersion,
+    latestVersion,
+    outdated: isNewerVersion(latestVersion, currentVersion)
+  };
+}
+function isNewerVersion(candidate, baseline) {
+  const candidateParts = parseVersion(candidate);
+  const baselineParts = parseVersion(baseline);
+  for (let index = 0; index < 3; index += 1) {
+    if (candidateParts[index] !== baselineParts[index]) {
+      return candidateParts[index] > baselineParts[index];
+    }
+  }
+  return false;
+}
+function parseVersion(value) {
+  const parts = value.split(".").map((part) => parseInt(part, 10));
+  return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+}
+function isCacheFresh(cache) {
+  const checkedAt = new Date(cache.checkedAt).getTime();
+  return Number.isFinite(checkedAt) && Date.now() - checkedAt < CACHE_TTL_MS;
+}
+async function readUpdateCache(cachePath) {
+  try {
+    const raw = await (0, import_promises5.readFile)(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
+      return void 0;
+    }
+    return { checkedAt: parsed.checkedAt, latestVersion: parsed.latestVersion, version: 1 };
+  } catch {
+    return void 0;
+  }
+}
+async function writeUpdateCache(cachePath, contents) {
+  try {
+    await (0, import_promises5.mkdir)((0, import_node_path5.dirname)(cachePath), { recursive: true });
+    await (0, import_promises5.writeFile)(cachePath, `${JSON.stringify(contents)}
+`, { encoding: "utf8", mode: 384 });
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(NPM_LATEST_URL, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const data = await response.json();
+    return typeof data.version === "string" && data.version.length > 0 ? data.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/version.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path6 = require("node:path");
+var cachedVersion;
+function getThreadnoteVersion() {
+  if (cachedVersion !== void 0) {
+    return cachedVersion;
+  }
+  try {
+    const packageJsonPath = (0, import_node_path6.join)(__dirname, "..", "package.json");
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf8"));
+    cachedVersion = typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown";
+  } catch {
+    cachedVersion = "unknown";
+  }
+  return cachedVersion;
+}
+
 // src/hooks.ts
 var MANAGED_HOOKS = [
   {
@@ -8142,7 +8288,7 @@ async function runHooksInstall(config, agent, options) {
 }
 async function runClaudeHooksInstall(options) {
   const path = expandPath(CLAUDE_SETTINGS_PATH);
-  const existingRaw = await exists(path) ? await (0, import_promises5.readFile)(path, "utf8") : "{}";
+  const existingRaw = await exists(path) ? await (0, import_promises6.readFile)(path, "utf8") : "{}";
   const parsed = parseJsonConfigObject(existingRaw) ?? {};
   const next = options.remove ? withoutThreadnoteHooks(parsed) : withThreadnoteHooks(parsed);
   const before = JSON.stringify(parsed);
@@ -8159,11 +8305,11 @@ async function runClaudeHooksInstall(options) {
     console.log("\nRe-run with --apply to actually modify the file.");
     return;
   }
-  await (0, import_promises5.mkdir)((0, import_node_path5.dirname)(path), { recursive: true });
+  await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path), { recursive: true });
   const serialized = `${JSON.stringify(next, void 0, 2)}
 `;
-  await (0, import_promises5.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
-  await (0, import_promises5.chmod)(path, 384);
+  await (0, import_promises6.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
+  await (0, import_promises6.chmod)(path, 384);
   console.log(`${options.remove ? "Removed" : "Installed"} threadnote-managed Claude hooks.`);
 }
 function withThreadnoteHooks(input2) {
@@ -8241,7 +8387,7 @@ async function hasManagedClaudeHooks() {
   if (!await exists(path)) {
     return false;
   }
-  const raw = await (0, import_promises5.readFile)(path, "utf8");
+  const raw = await (0, import_promises6.readFile)(path, "utf8");
   const parsed = parseJsonConfigObject(raw);
   if (!parsed || !isJsonObject(parsed.hooks)) {
     return false;
@@ -8259,7 +8405,7 @@ async function hasManagedClaudeHooks() {
 async function runPreCompactHook(config, options = {}) {
   try {
     const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
-    const project = repoRoot ? (0, import_node_path5.basename)(repoRoot) : "general";
+    const project = repoRoot ? (0, import_node_path7.basename)(repoRoot) : "general";
     await runHandoff(config, {
       blockers: "- none recorded",
       dryRun: options.dryRun === true,
@@ -8283,7 +8429,8 @@ async function runSessionStartHook(config, options = {}) {
     if (!repoRoot) {
       return;
     }
-    const project = (0, import_node_path5.basename)(repoRoot);
+    const project = (0, import_node_path7.basename)(repoRoot);
+    await emitUpdateBannerIfOutdated(config);
     process.stdout.write(`## Threadnote \u2014 latest context for ${project}
 
 `);
@@ -8300,10 +8447,36 @@ async function runSessionStartHook(config, options = {}) {
     );
   }
 }
+async function emitUpdateBannerIfOutdated(config) {
+  try {
+    const result = await checkForThreadnoteUpdate({
+      cachePath: (0, import_node_path7.join)(config.agentContextHome, ".update-state.json"),
+      currentVersion: getThreadnoteVersion()
+    });
+    if (!result || !result.outdated) {
+      return;
+    }
+    if (process.env.THREADNOTE_AUTO_UPDATE === "1") {
+      process.stdout.write(
+        `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Auto-updating in the background; the new version takes effect next session.
+
+`
+      );
+      spawnDetachedAutoUpdate();
+      return;
+    }
+    process.stdout.write(
+      `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Run: threadnote update
+
+`
+    );
+  } catch {
+  }
+}
 
 // src/seeding.ts
-var import_promises6 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
 async function runSeed(config, options) {
   const manifest = await readSeedManifest(config.manifestPath);
   const ignorePatterns = await loadIgnorePatterns();
@@ -8332,7 +8505,7 @@ async function runSeed(config, options) {
 }
 async function runInitManifest(config, options) {
   const manifestPath = expandPath(
-    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path6.join)(config.agentContextHome, USER_MANIFEST_NAME)
+    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path8.join)(config.agentContextHome, USER_MANIFEST_NAME)
   );
   const repoInputs = options.repo && options.repo.length > 0 ? options.repo : [getInvocationCwd()];
   const existingManifest = options.replace === true || !await exists(manifestPath) ? void 0 : await readSeedManifest(manifestPath);
@@ -8375,9 +8548,9 @@ async function runInitManifest(config, options) {
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path6.dirname)(manifestPath), false);
-  await (0, import_promises6.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises6.chmod)(manifestPath, 384);
+  await ensureDirectory((0, import_node_path8.dirname)(manifestPath), false);
+  await (0, import_promises7.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises7.chmod)(manifestPath, 384);
   console.log(`Wrote manifest: ${manifestPath}`);
   console.log("Seed with:");
   console.log("  threadnote seed --dry-run");
@@ -8407,13 +8580,13 @@ async function resolveRepoRoot(repoInput) {
 async function projectIdentity(path) {
   const expanded = expandPath(path);
   try {
-    return await (0, import_promises6.realpath)(expanded);
+    return await (0, import_promises7.realpath)(expanded);
   } catch (_err) {
     return expanded;
   }
 }
 function projectManifestForRepo(repoRoot, existingProjects) {
-  const baseName = uriSegment((0, import_node_path6.basename)(repoRoot));
+  const baseName = uriSegment((0, import_node_path8.basename)(repoRoot));
   const usedNames = new Set(existingProjects.map((project) => project.name));
   const usedUris = new Set(existingProjects.map((project) => project.uri));
   let name = baseName;
@@ -8435,7 +8608,7 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
   for (const pattern of project.seed) {
     const files = await resolveProjectPattern(projectRoot, pattern);
     for (const filePath of files) {
-      const relativePath = toPosixPath((0, import_node_path6.relative)(projectRoot, filePath));
+      const relativePath = toPosixPath((0, import_node_path8.relative)(projectRoot, filePath));
       if (seen.has(relativePath) || matchesIgnore(relativePath, ignorePatterns)) {
         continue;
       }
@@ -8453,20 +8626,20 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
 async function resolveProjectPattern(projectRoot, pattern) {
   const normalizedPattern = toPosixPath(pattern);
   if (!hasGlob(normalizedPattern)) {
-    const filePath = (0, import_node_path6.join)(projectRoot, normalizedPattern);
+    const filePath = (0, import_node_path8.join)(projectRoot, normalizedPattern);
     return await isFile(filePath) ? [filePath] : [];
   }
   const globBase = getGlobBase(normalizedPattern);
-  const basePath = (0, import_node_path6.join)(projectRoot, globBase);
+  const basePath = (0, import_node_path8.join)(projectRoot, globBase);
   if (!await exists(basePath)) {
     return [];
   }
   const regex = globToRegExp(normalizedPattern);
   const files = await walkFiles(basePath);
-  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path6.relative)(projectRoot, filePath))));
+  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path8.relative)(projectRoot, filePath))));
 }
 async function prepareSeedFile(config, candidate, dryRun) {
-  const content = await (0, import_promises6.readFile)(candidate.filePath, "utf8");
+  const content = await (0, import_promises7.readFile)(candidate.filePath, "utf8");
   const redactedContent = shouldRedactPath(candidate.relativePath) ? redactContent(candidate.relativePath, content) : content;
   const secretMatches = detectSecretMatches(redactedContent);
   if (secretMatches.length > 0) {
@@ -8478,14 +8651,14 @@ async function prepareSeedFile(config, candidate, dryRun) {
   if (redactedContent === content) {
     return candidate.filePath;
   }
-  const redactedPath = (0, import_node_path6.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
+  const redactedPath = (0, import_node_path8.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
   if (dryRun) {
     console.log(`Would write redacted copy: ${redactedPath}`);
     return redactedPath;
   }
-  await ensureDirectory((0, import_node_path6.dirname)(redactedPath), false);
-  await (0, import_promises6.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
-  await (0, import_promises6.chmod)(redactedPath, 384);
+  await ensureDirectory((0, import_node_path8.dirname)(redactedPath), false);
+  await (0, import_promises7.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
+  await (0, import_promises7.chmod)(redactedPath, 384);
   return redactedPath;
 }
 async function collectSkillCandidates(config) {
@@ -8510,7 +8683,7 @@ async function collectSkillCandidates(config) {
   for (const source of sources) {
     const files = await resolveAbsolutePattern(expandPath(source.pattern));
     for (const filePath of files) {
-      const content = await (0, import_promises6.readFile)(filePath, "utf8");
+      const content = await (0, import_promises7.readFile)(filePath, "utf8");
       const matches = detectSecretMatches(content);
       if (matches.length > 0) {
         console.log(`SKIP skill with possible secret: ${filePath}`);
@@ -8541,10 +8714,10 @@ async function resolveAbsolutePattern(pattern) {
   return files.filter((filePath) => regex.test(toPosixPath(filePath)));
 }
 function skillResourceUri(skill) {
-  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${uriSegment((0, import_node_path6.basename)((0, import_node_path6.dirname)(skill.filePath)))}-${skill.hash.slice(0, 12)}.md`;
+  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${uriSegment((0, import_node_path8.basename)((0, import_node_path8.dirname)(skill.filePath)))}-${skill.hash.slice(0, 12)}.md`;
 }
 async function loadIgnorePatterns() {
-  const raw = await (0, import_promises6.readFile)((0, import_node_path6.join)(toolRoot(), ".threadnoteignore"), "utf8");
+  const raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(toolRoot(), ".threadnoteignore"), "utf8");
   return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function matchesIgnore(relativePath, patterns) {
@@ -8615,9 +8788,9 @@ function detectSecretMatches(content) {
 }
 
 // src/share.ts
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_os4 = require("node:os");
-var import_node_path7 = require("node:path");
+var import_node_path9 = require("node:path");
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
 var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
@@ -8684,8 +8857,8 @@ async function runShareInit(config, remoteUrl, options) {
   if (await exists(gitdir)) {
     throw new Error(`Gitdir already exists at ${gitdir}; remove it or pick a different team name.`);
   }
-  await ensureDirectory((0, import_node_path7.dirname)(worktree), dryRun);
-  await ensureDirectory((0, import_node_path7.dirname)(gitdir), dryRun);
+  await ensureDirectory((0, import_node_path9.dirname)(worktree), dryRun);
+  await ensureDirectory((0, import_node_path9.dirname)(gitdir), dryRun);
   const git = await requiredExecutable("git");
   await maybeRun(dryRun, git, ["clone", `--separate-git-dir=${gitdir}`, "--", remoteUrl, worktree]);
   const newConfig = {
@@ -8716,7 +8889,7 @@ async function runShareInit(config, remoteUrl, options) {
 var SHARED_GITIGNORE_PATTERNS = ["**/.abstract.md", "**/.overview.md"];
 var SHARED_GITIGNORE_HEADER = "# Threadnote: ignore OpenViking-generated directory summaries.";
 async function ensureSharedGitignore(worktree, git, push) {
-  const gitignorePath = (0, import_node_path7.join)(worktree, ".gitignore");
+  const gitignorePath = (0, import_node_path9.join)(worktree, ".gitignore");
   const existing = await readFileIfExists(gitignorePath) ?? "";
   const lines = existing.split("\n").map((line) => line.trim());
   const missingPatterns = SHARED_GITIGNORE_PATTERNS.filter((pattern) => !lines.includes(pattern));
@@ -8735,7 +8908,7 @@ async function ensureSharedGitignore(worktree, git, push) {
     segments.push(SHARED_GITIGNORE_HEADER, "\n");
   }
   segments.push(missingPatterns.join("\n"), "\n");
-  await (0, import_promises7.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
+  await (0, import_promises8.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
   console.log(`Added ${missingPatterns.join(", ")} to ${portablePath(gitignorePath)}`);
   await maybeRun(false, git, ["-C", worktree, "add", ".gitignore"]);
   const commitResult = await runCommand(
@@ -8800,7 +8973,7 @@ async function runShareSync(config, options) {
   if (dryRun) {
     console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME])}`);
   } else if (pullResult && pullResult.exitCode !== 0) {
-    if (await exists((0, import_node_path7.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path7.join)(team.config.gitdir, "rebase-apply"))) {
+    if (await exists((0, import_node_path9.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path9.join)(team.config.gitdir, "rebase-apply"))) {
       throw new Error(
         `git pull --rebase reported conflicts in ${worktree}. The worktree is in a rebase-in-progress state.
 Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then re-run \`threadnote share sync\`.`
@@ -8976,10 +9149,10 @@ function normalizeTeamName(input2) {
   return candidate;
 }
 function teamsFilePath(config) {
-  return (0, import_node_path7.join)(config.agentContextHome, "share", "teams.json");
+  return (0, import_node_path9.join)(config.agentContextHome, "share", "teams.json");
 }
 function teamWorktreePath(config, team) {
-  return (0, import_node_path7.join)(
+  return (0, import_node_path9.join)(
     config.agentContextHome,
     "data",
     "viking",
@@ -8992,7 +9165,7 @@ function teamWorktreePath(config, team) {
   );
 }
 function teamGitdirPath(config, team) {
-  return (0, import_node_path7.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
+  return (0, import_node_path9.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
 async function readTeamsFile(config) {
   const path = teamsFilePath(config);
@@ -9035,13 +9208,13 @@ async function readTeamsFile(config) {
 }
 async function writeTeamsFile(config, contents) {
   const path = teamsFilePath(config);
-  await (0, import_promises7.mkdir)((0, import_node_path7.dirname)(path), { recursive: true });
+  await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(path), { recursive: true });
   const serializable = {
     defaultTeam: contents.defaultTeam,
     teams: contents.teams,
     version: contents.version
   };
-  await (0, import_promises7.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
+  await (0, import_promises8.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function resolveTeam(config, requested) {
@@ -9071,7 +9244,7 @@ async function assertWorktreeUsable(worktree) {
   if (!await isDirectory(worktree)) {
     throw new Error(`Cannot use ${worktree} as a worktree: not a directory.`);
   }
-  const entries = await (0, import_promises7.readdir)(worktree);
+  const entries = await (0, import_promises8.readdir)(worktree);
   if (entries.length > 0) {
     const preview = entries.slice(0, 5).join(", ");
     const suffix = entries.length > 5 ? `, +${entries.length - 5} more` : "";
@@ -9095,7 +9268,7 @@ async function walkMemoryFiles(root) {
   async function visit(path, depth) {
     let entries;
     try {
-      entries = await (0, import_promises7.readdir)(path, { withFileTypes: true });
+      entries = await (0, import_promises8.readdir)(path, { withFileTypes: true });
     } catch (err) {
       console.warn(`Skipping ${path} during shared-tree walk: ${err instanceof Error ? err.message : String(err)}`);
       return;
@@ -9104,7 +9277,7 @@ async function walkMemoryFiles(root) {
       if (entry.name === ".git") {
         continue;
       }
-      const full = (0, import_node_path7.join)(path, entry.name);
+      const full = (0, import_node_path9.join)(path, entry.name);
       if (entry.isDirectory()) {
         if (depth === 0 && !SHAREABLE_MEMORY_KIND_DIRS.includes(entry.name)) {
           continue;
@@ -9128,7 +9301,7 @@ async function walkMemoryFiles(root) {
   return out;
 }
 function workfileToVikingUri(config, team, filePath) {
-  const rel = (0, import_node_path7.relative)(team.worktree, filePath).split(import_node_path7.sep).join("/");
+  const rel = (0, import_node_path9.relative)(team.worktree, filePath).split(import_node_path9.sep).join("/");
   return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config, uri) {
@@ -9240,13 +9413,13 @@ async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun) {
     console.log(`Would run: ${formatShellCommand(ov, args)}`);
     return;
   }
-  const stagingDir = await (0, import_promises7.mkdtemp)((0, import_node_path7.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path7.join)(stagingDir, "body.txt");
+  const stagingDir = await (0, import_promises8.mkdtemp)((0, import_node_path9.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path9.join)(stagingDir, "body.txt");
   try {
-    await (0, import_promises7.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await (0, import_promises8.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config, ov, uri, tempPath, initialMode);
   } finally {
-    await (0, import_promises7.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises8.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode) {
@@ -9304,7 +9477,7 @@ ${stdout}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed") || output2.includes("network error") || output2.includes("error sending request") || output2.includes("http request failed") || output2.includes("connection refused") || output2.includes("connection reset") || output2.includes("timed out");
 }
 async function ingestSingleFile(ov, config, uri, filePath, initialMode) {
-  const content = await (0, import_promises7.readFile)(filePath, "utf8");
+  const content = await (0, import_promises8.readFile)(filePath, "utf8");
   await writeMemoryFile(config, ov, uri, content, initialMode, false);
 }
 async function removeWithRollback(config, ov, sourceUri, rollbackUri, worktree, dryRun, label) {
@@ -9346,7 +9519,7 @@ async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
   if (!relative3) {
     return;
   }
-  await (0, import_promises7.rm)((0, import_node_path7.join)(worktree, relative3), { force: true });
+  await (0, import_promises8.rm)((0, import_node_path9.join)(worktree, relative3), { force: true });
 }
 async function removeMemoryUri(config, ov, uri, dryRun) {
   const args = withIdentity(config, ["rm", uri]);
@@ -9403,8 +9576,8 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
       const oldRel = entries[index + 1];
       const newRel = entries[index + 2];
       if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path7.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path7.join)(worktree, newRel), relativePath: newRel, status: "added" });
+        changes.push({ path: (0, import_node_path9.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path9.join)(worktree, newRel), relativePath: newRel, status: "added" });
       }
       index += 3;
       continue;
@@ -9412,7 +9585,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
     const rel = entries[index + 1];
     if (rel) {
       const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path7.join)(worktree, rel), relativePath: rel, status });
+      changes.push({ path: (0, import_node_path9.join)(worktree, rel), relativePath: rel, status });
     }
     index += 2;
   }
@@ -9436,32 +9609,32 @@ async function applyChangesToOpenViking(config, team, changes) {
     if (!await isFile(change.path)) {
       continue;
     }
-    if (change.status === "modified" && await vikingResourceExists2(ov, config, uri)) {
-      console.warn(
-        `share sync: overwriting local ${uri} with the upstream version (local edits to the shared subtree are not preserved across sync).`
-      );
+    const ovHasResource = await vikingResourceExists2(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)";
+      console.warn(`share sync: ${uri}: ${reason}.`);
     }
     await ensureSharedDirectoryChain(config, ov, uri, false);
-    const writeMode = change.status === "modified" ? "replace" : "create";
+    const writeMode = ovHasResource ? "replace" : "create";
     await ingestSingleFile(ov, config, uri, change.path, writeMode);
   }
 }
 
 // src/lifecycle.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs5 = require("node:fs");
-var import_promises10 = require("node:fs/promises");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs6 = require("node:fs");
+var import_promises11 = require("node:fs/promises");
 var import_node_os6 = require("node:os");
-var import_node_path9 = require("node:path");
+var import_node_path11 = require("node:path");
 var import_node_process2 = require("node:process");
-var import_promises11 = require("node:readline/promises");
+var import_promises12 = require("node:readline/promises");
 
 // src/update.ts
-var import_node_fs4 = require("node:fs");
-var import_promises8 = require("node:fs/promises");
+var import_node_fs5 = require("node:fs");
+var import_promises9 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
-var import_node_path8 = require("node:path");
-var import_promises9 = require("node:readline/promises");
+var import_node_path10 = require("node:path");
+var import_promises10 = require("node:readline/promises");
 var import_node_process = require("node:process");
 var NPM_PACKAGE_NAME = "threadnote";
 var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
@@ -9509,7 +9682,7 @@ async function runUpdate(config, options) {
       console.log(`Update available. Run: threadnote update`);
     } else {
       console.log(
-        compareVersions(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
+        compareVersions2(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
       );
     }
     return;
@@ -9597,26 +9770,26 @@ async function maybeRunPostUpdateAfterRepair(config, options) {
 async function getUpdateInfo(config, options) {
   const currentVersion = await currentPackageVersion();
   const cached = options.preferFresh ? void 0 : await readFreshCache(config, options.registry);
-  const latestVersion = cached?.latestVersion ?? await fetchLatestVersion(options.registry);
+  const latestVersion = cached?.latestVersion ?? await fetchLatestVersion2(options.registry);
   if (!cached && options.allowCacheWrite) {
-    await writeUpdateCache(config, { checkedAt: (/* @__PURE__ */ new Date()).toISOString(), latestVersion, registry: options.registry });
+    await writeUpdateCache2(config, { checkedAt: (/* @__PURE__ */ new Date()).toISOString(), latestVersion, registry: options.registry });
   }
   return {
     currentVersion,
-    isUpdateAvailable: compareVersions(currentVersion, latestVersion) < 0,
+    isUpdateAvailable: compareVersions2(currentVersion, latestVersion) < 0,
     latestVersion,
     registry: options.registry
   };
 }
 async function currentPackageVersion() {
-  const rawPackage = await (0, import_promises8.readFile)((0, import_node_path8.join)(toolRoot(), "package.json"), "utf8");
+  const rawPackage = await (0, import_promises9.readFile)((0, import_node_path10.join)(toolRoot(), "package.json"), "utf8");
   const parsed = JSON.parse(rawPackage);
   if (!isJsonObject(parsed) || typeof parsed.version !== "string") {
     throw new Error("Could not read current threadnote package version.");
   }
   return parsed.version;
 }
-async function fetchLatestVersion(registry) {
+async function fetchLatestVersion2(registry) {
   const url = new URL(`${NPM_PACKAGE_NAME}/latest`, normalizeRegistry(registry));
   const controller = new AbortController();
   const timeout = setTimeout(() => {
@@ -9657,13 +9830,13 @@ async function readFreshCache(config, registry) {
     return void 0;
   }
 }
-async function writeUpdateCache(config, cache) {
+async function writeUpdateCache2(config, cache) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises8.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises9.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function updateCachePath(config) {
-  return (0, import_node_path8.join)(config.agentContextHome, "update-check.json");
+  return (0, import_node_path10.join)(config.agentContextHome, "update-check.json");
 }
 async function runApplicablePostUpdateMigrations(config, options) {
   const state = await readPostUpdateState(config);
@@ -9713,10 +9886,10 @@ async function applicablePostUpdateMigrations(config, options) {
     if (handled.has(migration.id)) {
       continue;
     }
-    if (compareVersions(options.fromVersion, migration.introducedIn) >= 0) {
+    if (compareVersions2(options.fromVersion, migration.introducedIn) >= 0) {
       continue;
     }
-    if (compareVersions(migration.introducedIn, options.toVersion) > 0) {
+    if (compareVersions2(migration.introducedIn, options.toVersion) > 0) {
       continue;
     }
     if (migration.requiresLegacyHandoffs === true && !await hasLegacyLifecycleHandoffCandidates(config)) {
@@ -9727,7 +9900,7 @@ async function applicablePostUpdateMigrations(config, options) {
   return applicable;
 }
 async function readPostUpdateMigrations() {
-  const raw = await readFileIfExists((0, import_node_path8.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
+  const raw = await readFileIfExists((0, import_node_path10.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
   if (!raw) {
     return [];
   }
@@ -9766,7 +9939,7 @@ function printPostUpdateMigration(migration) {
   }
 }
 async function confirmPostUpdateMigration(prompt) {
-  const readline = (0, import_promises9.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  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();
     return answer === "y" || answer === "yes";
@@ -9798,11 +9971,11 @@ async function readPostUpdateState(config) {
 }
 async function writePostUpdateState(config, state) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises8.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
+  await (0, import_promises9.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function postUpdateStatePath(config) {
-  return (0, import_node_path8.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
+  return (0, import_node_path10.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
 }
 async function resolveUpdateRuntime(runtime) {
   if (runtime !== "auto") {
@@ -9832,18 +10005,18 @@ async function runtimeThreadnoteBin(runtime) {
   if (runtime === "npm") {
     const result = await runCommand("npm", ["prefix", "--global"], { allowFailure: true });
     const prefix = result.stdout.trim();
-    return prefix ? (0, import_node_path8.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
+    return prefix ? (0, import_node_path10.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
   }
   if (runtime === "bun") {
     const result = await runCommand("bun", ["pm", "bin", "-g"], { allowFailure: true });
     const binDir = result.stdout.trim();
-    return binDir ? (0, import_node_path8.join)(binDir, NPM_PACKAGE_NAME) : void 0;
+    return binDir ? (0, import_node_path10.join)(binDir, NPM_PACKAGE_NAME) : void 0;
   }
-  return (0, import_node_path8.join)(process.env.DENO_INSTALL ?? (0, import_node_path8.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
+  return (0, import_node_path10.join)(process.env.DENO_INSTALL ?? (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
 }
 async function isExecutable(path) {
   try {
-    await (0, import_promises8.access)(path, import_node_fs4.constants.X_OK);
+    await (0, import_promises9.access)(path, import_node_fs5.constants.X_OK);
     return true;
   } catch (_err) {
     return false;
@@ -9884,9 +10057,9 @@ 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 compareVersions(currentVersion, latestVersion) {
-  const current = parseVersion(currentVersion);
-  const latest = parseVersion(latestVersion);
+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) {
@@ -9904,7 +10077,7 @@ function compareVersions(currentVersion, latestVersion) {
   }
   return current.prerelease.localeCompare(latest.prerelease);
 }
-function parseVersion(version) {
+function parseVersion2(version) {
   const normalized = version.trim().replace(/^v/, "");
   const [core2, prerelease] = normalized.split("-", 2);
   const parts = core2.split(".").map((part) => Number(part));
@@ -9934,9 +10107,9 @@ async function runDoctor(config, options) {
   checks.push(await commandShimCheck());
   checks.push(...await userAgentInstructionsChecks());
   checks.push(await manifestCheck(config.manifestPath));
-  checks.push(await fileCheck((0, import_node_path9.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
-  checks.push(await fileCheck((0, import_node_path9.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
-  checks.push(await fileCheck((0, import_node_path9.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
+  checks.push(await fileCheck((0, import_node_path11.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
+  checks.push(await fileCheck((0, import_node_path11.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
+  checks.push(await fileCheck((0, import_node_path11.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
   checks.push(await healthCheck(config));
   for (const check of checks) {
     console.log(`${formatStatus(check.status)} ${check.name}: ${check.detail}`);
@@ -9953,9 +10126,9 @@ async function runInstall(config, options) {
   const repairInvalidConfigs = options.repairInvalidConfigs === true;
   const dryRun = options.dryRun === true;
   await ensureDirectory(config.agentContextHome, dryRun);
-  await ensureDirectory((0, import_node_path9.join)(config.agentContextHome, "logs"), dryRun);
-  await ensureDirectory((0, import_node_path9.join)(config.agentContextHome, "redacted"), dryRun);
-  await ensureDirectory((0, import_node_path9.join)(config.agentContextHome, "mcp"), dryRun);
+  await ensureDirectory((0, import_node_path11.join)(config.agentContextHome, "logs"), dryRun);
+  await ensureDirectory((0, import_node_path11.join)(config.agentContextHome, "redacted"), dryRun);
+  await ensureDirectory((0, import_node_path11.join)(config.agentContextHome, "mcp"), dryRun);
   await installCommandShim(dryRun);
   await installUserAgentInstructions(dryRun);
   const serverPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
@@ -9981,17 +10154,17 @@ async function runInstall(config, options) {
   }
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path9.join)(config.agentContextHome, "ov.conf"),
+    destinationPath: (0, import_node_path11.join)(config.agentContextHome, "ov.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairOpenVikingConfig(content, config) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path9.join)(toolRoot(), "config", "ov.conf.template.json")
+    templatePath: (0, import_node_path11.join)(toolRoot(), "config", "ov.conf.template.json")
   });
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path9.join)(config.agentContextHome, "ovcli.conf"),
+    destinationPath: (0, import_node_path11.join)(config.agentContextHome, "ovcli.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairLegacyOvCliConfig(content) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path9.join)(toolRoot(), "config", "ovcli.conf.template.json")
+    templatePath: (0, import_node_path11.join)(toolRoot(), "config", "ovcli.conf.template.json")
   });
   if (options.start !== false) {
     const healthy = await repairServerHealth(config, dryRun);
@@ -10045,7 +10218,7 @@ async function runUninstall(config, options) {
   }
   console.log("Uninstalling local Threadnote setup.");
   await runStop(config, { dryRun });
-  await removePathIfExists((0, import_node_path9.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
+  await removePathIfExists((0, import_node_path11.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
   await removeLaunchAgent(dryRun);
   await removeMcpConfigs(options.mcp ?? "available", dryRun);
   await removeMcpSnippets(config, dryRun);
@@ -10102,16 +10275,16 @@ async function repairManifest(config, dryRun) {
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path9.dirname)(config.manifestPath), false);
+  await ensureDirectory((0, import_node_path11.dirname)(config.manifestPath), false);
   const currentContent = await readFileIfExists(config.manifestPath);
   if (currentContent !== void 0) {
     const backupPath = `${config.manifestPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises10.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises10.chmod)(backupPath, 384);
+    await (0, import_promises11.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises11.chmod)(backupPath, 384);
     console.log(`Backup: ${backupPath}`);
   }
-  await (0, import_promises10.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises10.chmod)(config.manifestPath, 384);
+  await (0, import_promises11.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises11.chmod)(config.manifestPath, 384);
   console.log(`Wrote replacement manifest: ${config.manifestPath}`);
 }
 async function repairServerHealth(config, dryRun) {
@@ -10152,16 +10325,16 @@ async function runStart(config, options) {
     );
   }
   const logPath = openVikingLogPath(config);
-  await ensureDirectory((0, import_node_path9.dirname)(logPath), false);
+  await ensureDirectory((0, import_node_path11.dirname)(logPath), false);
   if (options.foreground === true) {
     const result = await runInteractive(server, args);
     process.exitCode = result;
     return;
   }
-  const logFd = (0, import_node_fs5.openSync)(logPath, "a");
+  const logFd = (0, import_node_fs6.openSync)(logPath, "a");
   const child = spawnDetachedServerWithLog(server, args, logFd);
   child.unref();
-  await (0, import_promises10.writeFile)((0, import_node_path9.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
+  await (0, import_promises11.writeFile)((0, import_node_path11.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
 `, "utf8");
   const health = await waitForOpenVikingHealth(config, START_HEALTH_TIMEOUT_MS);
   if (health) {
@@ -10176,11 +10349,11 @@ function spawnDetachedServerWithLog(server, args, logFd) {
   try {
     return spawnDetachedServer(server, args, logFd);
   } finally {
-    (0, import_node_fs5.closeSync)(logFd);
+    (0, import_node_fs6.closeSync)(logFd);
   }
 }
 function spawnDetachedServer(server, args, logFd) {
-  return (0, import_node_child_process2.spawn)(server, args, {
+  return (0, import_node_child_process3.spawn)(server, args, {
     detached: true,
     stdio: ["ignore", logFd, logFd]
   });
@@ -10194,7 +10367,7 @@ async function runStop(config, options) {
       console.log(`No LaunchAgent found: ${launchAgentPath}`);
     }
   }
-  const pidPath = (0, import_node_path9.join)(config.agentContextHome, "openviking-server.pid");
+  const pidPath = (0, import_node_path11.join)(config.agentContextHome, "openviking-server.pid");
   const pidText = await readFileIfExists(pidPath);
   if (!pidText) {
     console.log("No pid file found for detached OpenViking server.");
@@ -10290,7 +10463,7 @@ async function pythonSystemCertificatesCheck() {
   };
 }
 async function commandShimCheck() {
-  const shimPath = (0, import_node_path9.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path11.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     return { name: "threadnote shim", status: "warn", detail: `${shimPath} missing; repair will create it` };
@@ -10356,11 +10529,11 @@ async function hasPythonModule(serverPath, moduleName) {
 async function siblingPythonForExecutable(executablePath) {
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises10.realpath)(executablePath);
+    resolvedPath = await (0, import_promises11.realpath)(executablePath);
   } catch (_err) {
     return void 0;
   }
-  const pythonPath = (0, import_node_path9.join)((0, import_node_path9.dirname)(resolvedPath), "python");
+  const pythonPath = (0, import_node_path11.join)((0, import_node_path11.dirname)(resolvedPath), "python");
   return await exists(pythonPath) ? pythonPath : void 0;
 }
 async function manifestCheck(path) {
@@ -10431,7 +10604,7 @@ async function offerToInstallUv() {
     );
     return false;
   }
-  const readline = (0, import_promises11.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+  const readline = (0, import_promises12.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
   let answer;
   try {
     answer = (await readline.question(
@@ -10554,38 +10727,38 @@ function printInstallNextSteps(options) {
 }
 async function writeTemplateIfMissing(options) {
   if (await exists(options.destinationPath)) {
-    const currentContent = await (0, import_promises10.readFile)(options.destinationPath, "utf8");
+    const currentContent = await (0, import_promises11.readFile)(options.destinationPath, "utf8");
     if (options.shouldRepair?.(currentContent) !== true) {
       console.log(`Already exists: ${options.destinationPath}`);
       return;
     }
-    const rendered2 = renderTemplate(await (0, import_promises10.readFile)(options.templatePath, "utf8"), options.config);
+    const rendered2 = renderTemplate(await (0, import_promises11.readFile)(options.templatePath, "utf8"), options.config);
     if (options.dryRun) {
       console.log(`Would repair generated config: ${options.destinationPath}`);
       return;
     }
     const backupPath = `${options.destinationPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises10.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises10.chmod)(backupPath, 384);
-    await (0, import_promises10.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
-    await (0, import_promises10.chmod)(options.destinationPath, 384);
+    await (0, import_promises11.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises11.chmod)(backupPath, 384);
+    await (0, import_promises11.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
+    await (0, import_promises11.chmod)(options.destinationPath, 384);
     console.log(`Repaired generated config: ${options.destinationPath}`);
     console.log(`Backup: ${backupPath}`);
     return;
   }
-  const rendered = renderTemplate(await (0, import_promises10.readFile)(options.templatePath, "utf8"), options.config);
+  const rendered = renderTemplate(await (0, import_promises11.readFile)(options.templatePath, "utf8"), options.config);
   if (options.dryRun) {
     console.log(`Would write ${options.destinationPath}`);
     return;
   }
-  await ensureDirectory((0, import_node_path9.dirname)(options.destinationPath), false);
-  await (0, import_promises10.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
-  await (0, import_promises10.chmod)(options.destinationPath, 384);
+  await ensureDirectory((0, import_node_path11.dirname)(options.destinationPath), false);
+  await (0, import_promises11.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
+  await (0, import_promises11.chmod)(options.destinationPath, 384);
   console.log(`Wrote ${options.destinationPath}`);
 }
 async function installCommandShim(dryRun) {
   const binDir = expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin");
-  const shimPath = (0, import_node_path9.join)(binDir, "threadnote");
+  const shimPath = (0, import_node_path11.join)(binDir, "threadnote");
   const existingContent = await readFileIfExists(shimPath);
   if (existingContent && !isManagedCommandShim(existingContent)) {
     console.log(`WARN not overwriting existing command shim: ${shimPath}`);
@@ -10601,12 +10774,12 @@ async function installCommandShim(dryRun) {
     return;
   }
   await ensureDirectory(binDir, false);
-  await (0, import_promises10.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
-  await (0, import_promises10.chmod)(shimPath, 493);
+  await (0, import_promises11.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
+  await (0, import_promises11.chmod)(shimPath, 493);
   console.log(`Wrote command shim: ${shimPath}`);
 }
 async function removeCommandShim(dryRun) {
-  const shimPath = (0, import_node_path9.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path11.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     console.log(`Already absent: ${shimPath}`);
@@ -10640,8 +10813,8 @@ async function installUserAgentInstructions(dryRun) {
       console.log(currentContent === void 0 ? `Would write ${targetPath}` : `Would update ${targetPath}`);
       continue;
     }
-    await ensureDirectory((0, import_node_path9.dirname)(targetPath), false);
-    await (0, import_promises10.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await ensureDirectory((0, import_node_path11.dirname)(targetPath), false);
+    await (0, import_promises11.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(currentContent === void 0 ? `Wrote ${targetPath}` : `Updated ${targetPath}`);
   }
 }
@@ -10678,7 +10851,7 @@ async function removeUserAgentInstructions(dryRun) {
       console.log(`Would update ${targetPath}`);
       continue;
     }
-    await (0, import_promises10.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await (0, import_promises11.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(`Updated ${targetPath}`);
   }
 }
@@ -10698,7 +10871,7 @@ async function renderUserAgentInstructions(target) {
   ].join("\n");
 }
 async function renderUserAgentInstructionsBlock() {
-  const instructions = (await (0, import_promises10.readFile)((0, import_node_path9.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
+  const instructions = (await (0, import_promises11.readFile)((0, import_node_path11.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
   return `${USER_INSTRUCTIONS_START_MARKER}
 ${instructions}
 ${USER_INSTRUCTIONS_END_MARKER}`;
@@ -10776,9 +10949,9 @@ async function installLaunchAgent(config, dryRun) {
   if ((0, import_node_os6.platform)() !== "darwin") {
     throw new Error("launchd autostart is only supported on macOS.");
   }
-  const source = (0, import_node_path9.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
+  const source = (0, import_node_path11.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
   const destination = expandPath(`~/Library/LaunchAgents/${LAUNCHD_LABEL}.plist`);
-  const rendered = renderTemplate(await (0, import_promises10.readFile)(source, "utf8"), config);
+  const rendered = renderTemplate(await (0, import_promises11.readFile)(source, "utf8"), config);
   if (dryRun) {
     console.log(`Would write ${destination}`);
     console.log(`Would run: launchctl unload ${destination}`);
@@ -10786,9 +10959,9 @@ async function installLaunchAgent(config, dryRun) {
     console.log(`Would run: launchctl start ${LAUNCHD_LABEL}`);
     return;
   }
-  await ensureDirectory((0, import_node_path9.dirname)(destination), false);
-  await ensureDirectory((0, import_node_path9.dirname)(openVikingLogPath(config)), false);
-  await (0, import_promises10.writeFile)(destination, rendered, "utf8");
+  await ensureDirectory((0, import_node_path11.dirname)(destination), false);
+  await ensureDirectory((0, import_node_path11.dirname)(openVikingLogPath(config)), false);
+  await (0, import_promises11.writeFile)(destination, rendered, "utf8");
   await maybeRun(false, "launchctl", ["unload", destination], { allowFailure: true });
   await maybeRun(false, "launchctl", ["load", destination]);
   await maybeRun(false, "launchctl", ["start", LAUNCHD_LABEL]);
@@ -10851,7 +11024,7 @@ function isGeneratedLocalPilotConfig(parsed, config) {
   if (typeof parsed.default_user !== "string") {
     return false;
   }
-  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path9.join)(config.agentContextHome, "data")) {
+  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path11.join)(config.agentContextHome, "data")) {
     return false;
   }
   return isJsonObject(parsed.server) && parsed.server.host === config.host && String(parsed.server.port) === String(config.port);