threadnote 0.6.0 → 0.6.1

package/README.md

@@ -240,7 +240,11 @@ For deterministic moments where the agent shouldn't have to remember, Threadnote
 - **`PreCompact`** auto-stores a handoff snapshot for the current repo right before Claude compacts the conversation,
   so the next turn can recall it even if the agent forgot to write a handoff manually.
 - **`SessionStart`** preloads the latest threadnote handoff/feature memory for the current repo into the new session
-  context, so the first turn already knows where you left off.
+  context, so the first turn already knows where you left off. The same hook also runs a daily-cached check against
+  the npm registry and prints a one-line `[threadnote] vX.Y.Z available; run threadnote update` banner when the
+  installed version is behind, so you stop missing releases. Set `THREADNOTE_AUTO_UPDATE=1` to skip the nag and have
+  the hook spawn `threadnote update --yes` in the background instead — the new version takes effect on the next
+  session.
 
 Install them per agent (Codex / Cursor / Copilot are no-ops today — Threadnote prints a clear explanation):
 

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");
@@ -8109,6 +8109,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 +8264,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 +8281,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 +8363,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 +8381,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 +8405,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 +8423,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 +8481,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 +8524,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 +8556,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 +8584,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 +8602,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 +8627,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 +8659,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 +8690,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 +8764,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 +8833,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 +8865,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 +8884,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 +8949,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 +9125,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 +9141,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 +9184,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 +9220,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 +9244,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 +9253,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 +9277,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 +9389,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 +9453,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 +9495,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 +9552,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 +9561,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 +9585,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 +9658,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 +9746,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 +9806,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 +9862,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 +9876,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 +9915,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 +9947,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 +9981,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 +10033,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 +10053,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 +10083,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 +10102,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 +10130,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 +10194,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 +10251,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 +10301,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 +10325,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 +10343,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 +10439,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 +10505,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 +10580,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 +10703,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 +10750,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 +10789,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 +10827,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 +10847,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 +10925,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 +10935,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 +11000,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);

package/package.json

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