threadnote 0.5.0 → 0.6.1

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");
@@ -7240,12 +7240,16 @@ async function runRemember(config, options) {
     project: normalizeOptionalMetadata(options.project),
     sourceAgentClient: options.sourceAgentClient ?? "codex",
     status: options.status ?? "active",
-    supersedes: options.replace,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     topic: normalizeOptionalMetadata(options.topic)
   };
-  const memory = formatMemoryDocument("MEMORY", metadata, text.trim());
-  await storeMemory(config, memory, { dryRun: options.dryRun === true, metadata, replaceUri: options.replace });
+  await storeMemory(config, {
+    bodyText: text.trim(),
+    dryRun: options.dryRun === true,
+    metadata,
+    replaceUri: options.replace,
+    title: "MEMORY"
+  });
 }
 async function runMigrateMemories(config, options) {
   const dryRun = options.dryRun === true;
@@ -7418,8 +7422,14 @@ async function runList(config, uri, options) {
   await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
 }
 async function runHandoff(config, options) {
-  const { handoff, metadata } = await buildHandoff(options);
-  await storeMemory(config, handoff, { dryRun: options.dryRun === true, metadata, replaceUri: options.replace });
+  const { bodyText, metadata } = await buildHandoff(options);
+  await storeMemory(config, {
+    bodyText,
+    dryRun: options.dryRun === true,
+    metadata,
+    replaceUri: options.replace,
+    title: "HANDOFF"
+  });
 }
 async function runArchive(config, uri, options) {
   assertVikingUri(uri);
@@ -7436,12 +7446,12 @@ async function runArchive(config, uri, options) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       topic: normalizeOptionalMetadata(options.topic)
     };
-    const archiveMemory2 = formatMemoryDocument(
-      "MEMORY",
-      fallbackMetadata,
-      ["Archived original Threadnote memory.", "", "<original memory content would be read here>"].join("\n")
-    );
-    await storeMemory(config, archiveMemory2, { dryRun: true, metadata: fallbackMetadata });
+    await storeMemory(config, {
+      bodyText: ["Archived original Threadnote memory.", "", "<original memory content would be read here>"].join("\n"),
+      dryRun: true,
+      metadata: fallbackMetadata,
+      title: "MEMORY"
+    });
     console.log(formatShellCommand(ov, withIdentity(config, ["rm", uri])));
     return;
   }
@@ -7458,12 +7468,12 @@ async function runArchive(config, uri, options) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     topic: normalizeOptionalMetadata(options.topic) ?? inferredMetadata.topic
   };
-  const archiveMemory = formatMemoryDocument(
-    "MEMORY",
+  await storeMemory(config, {
+    bodyText: ["Archived original Threadnote memory.", "", original].join("\n"),
+    dryRun: false,
     metadata,
-    ["Archived original Threadnote memory.", "", original].join("\n")
-  );
-  await storeMemory(config, archiveMemory, { dryRun: false, metadata });
+    title: "MEMORY"
+  });
   const removedOriginal = await removeVikingResourceWithRetry(ov, config, uri);
   if (removedOriginal) {
     console.log(`Archived original memory: ${uri}`);
@@ -7544,14 +7554,19 @@ async function printExactMemoryMatches(config, ov, query, options) {
   console.log("\nExact durable memory matches:");
   console.log(outputs.join("\n\n"));
 }
-async function storeMemory(config, memory, options) {
+async function storeMemory(config, options) {
   if (options.replaceUri) {
     assertVikingUri(options.replaceUri);
   }
   const ov = await openVikingCliForMode(options.dryRun);
   const memoryPath = (0, import_node_path4.join)(config.agentContextHome, "last-memory.txt");
-  const memoryUri = memoryUriFor(config, memory, options.metadata);
-  const writeMode = await memoryWriteMode(ov, config, memoryUri, options.metadata);
+  const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
+  const candidateMemory = formatMemoryDocument(options.title, candidateMetadata, options.bodyText);
+  const memoryUri = memoryUriFor(config, candidateMemory, candidateMetadata);
+  const isInPlaceUpdate = options.replaceUri !== void 0 && options.replaceUri === memoryUri;
+  const finalMetadata = isInPlaceUpdate ? { ...options.metadata, supersedes: void 0 } : candidateMetadata;
+  const memory = isInPlaceUpdate ? formatMemoryDocument(options.title, finalMetadata, options.bodyText) : candidateMemory;
+  const writeMode = await memoryWriteMode(ov, config, memoryUri, finalMetadata);
   if (options.dryRun) {
     console.log(memory);
     console.log("\nWould run:");
@@ -7571,17 +7586,17 @@ async function storeMemory(config, memory, options) {
         ])
       )
     );
-    if (options.replaceUri && options.replaceUri !== memoryUri) {
+    if (options.replaceUri && !isInPlaceUpdate) {
       console.log(formatShellCommand(ov, withIdentity(config, ["rm", options.replaceUri])));
     }
     return;
   }
   await (0, import_promises4.writeFile)(memoryPath, memory, { encoding: "utf8", mode: 384 });
   await (0, import_promises4.chmod)(memoryPath, 384);
-  await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, options.metadata));
+  await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, finalMetadata));
   await writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode);
   console.log(`Stored memory: ${memoryUri}`);
-  if (options.replaceUri && options.replaceUri !== memoryUri) {
+  if (options.replaceUri && !isInPlaceUpdate) {
     const removedReplacedMemory = await removeVikingResourceWithRetry(ov, config, options.replaceUri);
     if (removedReplacedMemory) {
       console.log(`Forgot replaced memory: ${options.replaceUri}`);
@@ -7590,7 +7605,7 @@ async function storeMemory(config, memory, options) {
         `Replacement stored, but the superseded memory is still processing. Retry later: threadnote forget ${options.replaceUri}`
       );
     }
-  } else if (options.replaceUri === memoryUri) {
+  } else if (isInPlaceUpdate) {
     console.log(`Updated existing memory in place: ${memoryUri}`);
   }
 }
@@ -8043,11 +8058,10 @@ async function buildHandoff(options) {
     project: normalizeOptionalMetadata(options.project) ?? repoName,
     sourceAgentClient: options.sourceAgentClient ?? "codex",
     status: "active",
-    supersedes: options.replace,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     topic: normalizeOptionalMetadata(options.topic)
   };
-  const body = [
+  const bodyText = [
     `repo: ${repoName}`,
     `repo_path: ${repoRoot}`,
     `branch: ${branch || "unknown"}`,
@@ -8071,7 +8085,7 @@ async function buildHandoff(options) {
     "next_step:",
     options.nextStep ?? "- inspect the current repo state and continue from this handoff"
   ].join("\n");
-  return { handoff: formatMemoryDocument("HANDOFF", metadata, body), metadata };
+  return { bodyText, metadata };
 }
 async function gitTouchedFiles(cwd) {
   const changedFiles = await gitValue(["diff", "--name-only", "HEAD"], cwd);
@@ -8095,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 = [
   {
@@ -8128,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);
@@ -8145,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) {
@@ -8227,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;
@@ -8245,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,
@@ -8269,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}
 
 `);
@@ -8286,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();
@@ -8318,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);
@@ -8361,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");
@@ -8393,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;
@@ -8421,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;
       }
@@ -8439,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) {
@@ -8464,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) {
@@ -8496,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}`);
@@ -8527,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) {
@@ -8601,14 +8764,16 @@ 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"];
 var DEFAULT_GIT_REMOTE_NAME = "origin";
 var SCRUBBER_PATTERNS = [
+  // Credentials: never redactable. Blocking is the only safe response —
+  // automated redaction risks false negatives that leave material in git.
   { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
   { name: "API key (sk-...)", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
   { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
@@ -8621,8 +8786,35 @@ var SCRUBBER_PATTERNS = [
   { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ },
   // Slack tokens: xoxa/xoxb/xoxc (configuration)/xoxd (legacy user cookie)/
   // xoxe (refresh)/xoxp/xoxr/xoxs, with optional -N- segment for the workspace tier.
-  { name: "Slack token", regex: /\bxox[abcdeprs](?:-\d-)?[A-Za-z0-9._-]{10,}/i }
+  { name: "Slack token", regex: /\bxox[abcdeprs](?:-\d-)?[A-Za-z0-9._-]{10,}/i },
+  // Soft leaks: block by default (so the agent sees them and decides), but
+  // allow opt-in redaction so curated memories with incidental matches can
+  // ship without a manual rewrite. Local home paths are the recurring
+  // real-world leak; the regexes greedily consume the whole path segment
+  // (including subdirectories) up to whitespace or common closing punctuation
+  // so redaction collapses an entire path to a single placeholder rather than
+  // leaving the subpath visible.
+  { name: "macOS home path", placeholder: "<local-path>", regex: /\/Users\/[^\s)>"'`,]+/ },
+  { name: "linux home path", placeholder: "<local-path>", regex: /\b\/home\/[^\s)>"'`,]+/ }
 ];
+function applyScrubber(content, { redact }) {
+  let cleaned = content;
+  const redactions = [];
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (!pattern.regex.test(cleaned)) {
+      continue;
+    }
+    if (!pattern.placeholder || !redact) {
+      return { blocker: pattern.name, cleaned: content, redactions: [] };
+    }
+    const flags = pattern.regex.flags.includes("g") ? pattern.regex.flags : `${pattern.regex.flags}g`;
+    const globalRegex = new RegExp(pattern.regex.source, flags);
+    const matches = cleaned.match(globalRegex) ?? [];
+    cleaned = cleaned.replace(globalRegex, pattern.placeholder);
+    redactions.push({ count: matches.length, name: pattern.name });
+  }
+  return { cleaned, redactions };
+}
 async function runShareInit(config, remoteUrl, options) {
   if (!remoteUrl.trim()) {
     throw new Error("Provide a git remote URL for the shared memories repo.");
@@ -8641,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 = {
@@ -8673,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));
@@ -8692,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(
@@ -8757,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\`.`
@@ -8787,16 +8979,41 @@ async function runSharePublish(config, sourceUri, options) {
   assertVikingUri(sourceUri);
   const team = await resolveTeam(config, options.team);
   const dryRun = options.dryRun === true;
+  const preview = options.preview === true;
   if (isInSharedNamespace(config, sourceUri)) {
     throw new Error(`Memory ${sourceUri} is already in the shared namespace.`);
   }
   const ov = await openVikingCliForMode(dryRun);
-  const content = await readMemoryContent(config, ov, sourceUri, dryRun);
-  const blocker = scrubberBlocker(content);
-  if (blocker) {
-    throw new Error(`Refusing to publish ${sourceUri}: possible ${blocker}. Strip the sensitive value, then retry.`);
-  }
+  const rawContent = await readMemoryContent(config, ov, sourceUri, dryRun);
+  const stripped = stripPersonalProvenance(rawContent);
+  const scrub = applyScrubber(stripped, { redact: options.redact === true });
   const targetUri = sharedUriFor(config, sourceUri, team.name);
+  if (preview) {
+    console.log(`PREVIEW source: ${sourceUri}`);
+    console.log(`PREVIEW destination: ${targetUri}`);
+    if (scrub.blocker) {
+      console.log(
+        `PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or rerun with --redact for soft-leak patterns.`
+      );
+      return;
+    }
+    for (const redaction of scrub.redactions) {
+      console.log(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
+    }
+    console.log("-----BEGIN PREVIEW-----");
+    console.log(scrub.cleaned);
+    console.log("-----END PREVIEW-----");
+    return;
+  }
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to publish ${sourceUri}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
+    );
+  }
+  for (const redaction of scrub.redactions) {
+    console.log(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
+  }
+  const content = scrub.cleaned;
   if (!dryRun && await vikingResourceExists2(ov, config, targetUri)) {
     throw new Error(
       `Refusing to publish: ${targetUri} already exists in the shared namespace. Inspect it via threadnote read; if it should be replaced, forget the existing shared copy first.`
@@ -8908,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",
@@ -8924,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);
@@ -8967,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) {
@@ -9003,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` : "";
@@ -9027,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;
@@ -9036,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;
@@ -9060,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) {
@@ -9092,8 +9309,26 @@ function vikingUriToWorktreeRelative(config, uri, team) {
   }
   return uri.slice(prefix.length);
 }
-function scrubberBlocker(content) {
-  return SCRUBBER_PATTERNS.find((pattern) => pattern.regex.test(content))?.name;
+function stripPersonalProvenance(content) {
+  const lines = content.split("\n");
+  let headerEnd = lines.length;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].trim() === "") {
+      headerEnd = index;
+      break;
+    }
+  }
+  const cleaned = [];
+  for (let index = 0; index < headerEnd; index += 1) {
+    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
+      continue;
+    }
+    cleaned.push(lines[index]);
+  }
+  for (let index = headerEnd; index < lines.length; index += 1) {
+    cleaned.push(lines[index]);
+  }
+  return cleaned.join("\n");
 }
 async function readMemoryContent(config, ov, uri, dryRun) {
   const args = withIdentity(config, ["read", uri]);
@@ -9154,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) {
@@ -9218,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) {
@@ -9260,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]);
@@ -9317,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;
@@ -9326,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;
   }
@@ -9350,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/";
@@ -9423,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;
@@ -9511,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(() => {
@@ -9571,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);
@@ -9627,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)) {
@@ -9641,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 [];
   }
@@ -9680,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";
@@ -9712,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") {
@@ -9746,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;
@@ -9798,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) {
@@ -9818,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));
@@ -9848,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}`);
@@ -9867,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]);
@@ -9895,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);
@@ -9959,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);
@@ -10016,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) {
@@ -10066,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) {
@@ -10090,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]
   });
@@ -10108,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.");
@@ -10204,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` };
@@ -10270,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) {
@@ -10345,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(
@@ -10468,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}`);
@@ -10515,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}`);
@@ -10554,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}`);
   }
 }
@@ -10592,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}`);
   }
 }
@@ -10612,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}`;
@@ -10690,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}`);
@@ -10700,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]);
@@ -10765,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);
@@ -10911,7 +11146,13 @@ async function main() {
   share.command("sync").description("Pull, reindex, and push the shared memories repo for a team").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message when auto-committing local edits").option("--no-auto-commit", "Refuse to sync if there are uncommitted local changes").option("--no-push", "Skip the push step after pulling and reindexing").option("--dry-run", "Print actions without running them").action(async (options) => {
     await runShareSync(getRuntimeConfig(program2), options);
   });
-  share.command("publish").description("Move a personal memory into the shared team namespace, commit and push").argument("<viking-uri>", "viking:// memory URI to publish").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message override").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").action(async (uri, options) => {
+  share.command("publish").description("Move a personal memory into the shared team namespace, commit and push").argument("<viking-uri>", "viking:// memory URI to publish").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message override").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").option(
+    "--preview",
+    "Print the exact bytes that would land in the shared git repo (after frontmatter strip and scrubber redaction) without writing, committing, or pushing"
+  ).option(
+    "--redact",
+    "Replace soft-leak matches (local paths) with placeholders and continue; credentials still block"
+  ).action(async (uri, options) => {
     await runSharePublish(getRuntimeConfig(program2), uri, options);
   });
   share.command("unpublish").description("Pull a shared memory back into the personal namespace, commit removal and push").argument("<viking-uri>", "viking:// memory URI inside a team shared subtree").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message override").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").action(async (uri, options) => {