threadnote 0.7.6 → 0.7.8

package/README.md

@@ -43,7 +43,8 @@ which memory to keep/update, which old handoffs to archive, and which exact dupl
 
 **Still working on the same issue?**
 Use `threadnote remember --replace <uri>` or `threadnote handoff --replace <uri>` to keep one current-state memory fresh
-instead of accumulating near-duplicate progress notes.
+instead of accumulating near-duplicate progress notes. Replacing a shared `durable/` URI updates that shared memory in
+place and pushes the shared repo, so you do not need a separate `share publish` step.
 
 ## Memory Lifecycle
 
@@ -179,10 +180,15 @@ threadnote update
 Check without changing anything:
 
 ```bash
+threadnote version
 threadnote update --check
 threadnote update --dry-run
 ```
 
+`threadnote version` prints the installed version, latest npm version, and GitHub release notes. When no update is
+available, it shows the current release notes; when an update is available, it shows every newer version. `threadnote
+update` prints the same full "What's new" diff when an update is available.
+
 After updating, restart Cursor, Copilot, Codex, Claude, or open a fresh agent session so MCP tools reload.
 
 Some releases include post-update memory migrations. `threadnote update` runs the new package's migration prompt after
@@ -333,8 +339,9 @@ This is it! Start working with your agents as usual. The agent will automaticall
 - `install`: installs `openviking[local-embed]==0.3.12` if missing, creates `~/.openviking` config files if absent,
   writes the command shim, upserts user-level agent instructions, and starts/checks OpenViking health by default. Use
   `--no-start` to skip the health check.
+- `version`: prints the installed Threadnote version, latest npm version, and release notes for newer GitHub releases.
 - `update`: updates the published Threadnote package, then runs `repair` so shims and MCP config point at the new
-  version.
+  version. When an update is available, it prints release notes for the full version diff.
 - `repair`: fixes install/config/shim/manifest/server health issues and rewrites Codex/Claude/Cursor/Copilot MCP configs
   from the current checkout.
 - `start`: starts `openviking-server` on `127.0.0.1:1933`.
@@ -347,8 +354,9 @@ This is it! Start working with your agents as usual. The agent will automaticall
   reusable workflow guidance. Use `seed-skills --native` only after configuring a working VLM provider.
 - `mcp-install codex|claude|cursor|copilot`: installs or prints OpenViking MCP configuration for Codex, Claude, Cursor,
   or GitHub Copilot in VS Code.
-- `remember`: stores a durable memory. Use `--replace <uri>` to store an updated memory and remove a superseded one
-  after the new memory succeeds. Use `--kind`, `--project`, and `--topic` to store lifecycle-aware current knowledge.
+- `remember`: stores a durable memory. Use `--replace <uri>` to store an updated memory and remove a superseded personal
+  memory after the new memory succeeds; if `<uri>` is shared, Threadnote updates that shared memory in place and pushes
+  the shared repo. Use `--kind`, `--project`, and `--topic` to store lifecycle-aware current knowledge.
 - `migrate-memories`: migrates legacy session-only `MEMORY` and `HANDOFF` records into durable memory files. Run
   `migrate-memories --dry-run` first; use `--all-accounts` when importing from older local OpenViking accounts.
 - `migrate-lifecycle`: moves clear legacy handoff memories from the old events path into archived lifecycle handoff

package/dist/mcp_server.cjs

@@ -28477,25 +28477,25 @@ var Protocol = class {
     });
   }
   _resetTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (!info)
+    const info2 = this._timeoutInfo.get(messageId);
+    if (!info2)
       return false;
-    const totalElapsed = Date.now() - info.startTime;
-    if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
+    const totalElapsed = Date.now() - info2.startTime;
+    if (info2.maxTotalTimeout && totalElapsed >= info2.maxTotalTimeout) {
       this._timeoutInfo.delete(messageId);
       throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
-        maxTotalTimeout: info.maxTotalTimeout,
+        maxTotalTimeout: info2.maxTotalTimeout,
         totalElapsed
       });
     }
-    clearTimeout(info.timeoutId);
-    info.timeoutId = setTimeout(info.onTimeout, info.timeout);
+    clearTimeout(info2.timeoutId);
+    info2.timeoutId = setTimeout(info2.onTimeout, info2.timeout);
     return true;
   }
   _cleanupTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (info) {
-      clearTimeout(info.timeoutId);
+    const info2 = this._timeoutInfo.get(messageId);
+    if (info2) {
+      clearTimeout(info2.timeoutId);
       this._timeoutInfo.delete(messageId);
     }
   }
@@ -28540,8 +28540,8 @@ var Protocol = class {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
-    for (const info of this._timeoutInfo.values()) {
-      clearTimeout(info.timeoutId);
+    for (const info2 of this._timeoutInfo.values()) {
+      clearTimeout(info2.timeoutId);
     }
     this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
@@ -30036,8 +30036,8 @@ function validateToolName(name) {
 function issueToolNameWarning(name, warnings) {
   if (warnings.length > 0) {
     console.warn(`Tool name validation warning for "${name}":`);
-    for (const warning of warnings) {
-      console.warn(`  - ${warning}`);
+    for (const warning2 of warnings) {
+      console.warn(`  - ${warning2}`);
     }
     console.warn("Tool registration will proceed, but this may cause compatibility issues.");
     console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
@@ -33591,6 +33591,39 @@ var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+
+// src/cli_ui.ts
+var import_node_process2 = require("node:process");
+var ANSI = {
+  blue: "\x1B[34m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+function color(name, text) {
+  if (!shouldUseColor()) {
+    return text;
+  }
+  return `${ANSI[name]}${text}${ANSI.reset}`;
+}
+function command(text) {
+  return color("cyan", text);
+}
+function info(text) {
+  return color("cyan", text);
+}
+function warning(text) {
+  return color("yellow", text);
+}
+function shouldUseColor() {
+  return import_node_process2.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.CI === void 0 && process.env.TERM !== "dumb";
+}
+
+// src/utils.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -33609,11 +33642,11 @@ function redactText(content) {
   ).replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{16,}/g, "sk-[REDACTED]").replace(/gh[pousr]_[A-Za-z0-9_]{16,}/g, "gh_[REDACTED]");
 }
 async function requiredOpenVikingCli() {
-  const command = await findExecutable(["ov", "openviking"]);
-  if (!command) {
+  const command2 = await findExecutable(["ov", "openviking"]);
+  if (!command2) {
     throw new Error("Neither ov nor openviking was found in PATH. Run threadnote install first.");
   }
-  return command;
+  return command2;
 }
 async function openVikingCliForMode(dryRun) {
   if (dryRun) {
@@ -33621,16 +33654,16 @@ async function openVikingCliForMode(dryRun) {
   }
   return requiredOpenVikingCli();
 }
-async function requiredExecutable(command) {
-  const executable = await findExecutable([command]);
+async function requiredExecutable(command2) {
+  const executable = await findExecutable([command2]);
   if (!executable) {
-    throw new Error(`${command} was not found in PATH.`);
+    throw new Error(`${command2} was not found in PATH.`);
   }
   return executable;
 }
 async function findExecutable(commands) {
-  for (const command of commands) {
-    const result = await runCommand("which", [command], { allowFailure: true });
+  for (const command2 of commands) {
+    const result = await runCommand("which", [command2], { allowFailure: true });
     if (result.exitCode === 0 && result.stdout.trim()) {
       return result.stdout.trim();
     }
@@ -33639,7 +33672,8 @@ async function findExecutable(commands) {
 }
 async function maybeRun(dryRun, executable, args, options = {}) {
   const cwdSuffix = options.cwd ? ` (cwd: ${options.cwd})` : "";
-  console.log(`${dryRun ? "Would run" : "Running"}: ${formatShellCommand(executable, args)}${cwdSuffix}`);
+  const label = dryRun ? warning("Would run") : info("Running");
+  console.log(`${label}: ${command(formatShellCommand(executable, args))}${cwdSuffix}`);
   if (dryRun) {
     return void 0;
   }
@@ -34445,9 +34479,9 @@ async function syncSharedReposBeforeAgentRead(config2) {
     const remainingBehind = new Set(state.behindTeams);
     for (const team of syncTeams) {
       try {
-        const warning = await runShareSyncQuiet(config2, state, { team });
-        if (warning) {
-          warnings.push(warning);
+        const warning2 = await runShareSyncQuiet(config2, state, { team });
+        if (warning2) {
+          warnings.push(warning2);
         } else {
           remainingBehind.delete(team);
           syncedTeams.push(team);
@@ -34529,8 +34563,8 @@ async function refreshShareUpdateState(config2, options) {
     state,
     async () => refreshShareUpdateStateLocked(config2, state, options)
   );
-  for (const warning of warnings) {
-    console.error(warning);
+  for (const warning2 of warnings) {
+    console.error(warning2);
   }
 }
 async function refreshShareUpdateStateLocked(config2, state, options) {
@@ -34726,7 +34760,35 @@ function workfileToVikingUri(config2, team, filePath) {
   return `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config2, uri) {
-  return uri.startsWith(`viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`);
+  return sharedTeamNameForUri(config2, uri) !== void 0;
+}
+function sharedTeamNameForUri(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team] = uri.slice(prefix.length).split("/");
+  return team || void 0;
+}
+function sharedMemoryUriParts(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team, kind, scope, project, ...topicParts] = uri.slice(prefix.length).split("/");
+  if (!team) {
+    return void 0;
+  }
+  if (kind !== "durable" || scope !== "projects" || !project || topicParts.length === 0) {
+    return { team };
+  }
+  const topicPath = topicParts.join("/");
+  return {
+    kind,
+    project,
+    team,
+    topic: topicPath.endsWith(".md") ? topicPath.slice(0, -".md".length) : topicPath
+  };
 }
 function sharedUriFor(config2, personalUri, team) {
   const prefix = `viking://user/${uriSegment(config2.user)}/memories/`;
@@ -34889,14 +34951,14 @@ async function waitForOvQueue(ov, config2, options = {}) {
     console.error(result.stderr.trim());
   }
 }
-function isTransientOvFailure(stderr, stdout) {
+function isTransientOvFailure(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed") || output.includes("network error") || output.includes("error sending request") || output.includes("http request failed") || output.includes("connection refused") || output.includes("connection reset") || output.includes("timed out");
 }
-function isResourceBusyFailure(stderr, stdout) {
+function isResourceBusyFailure(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed");
 }
 async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
@@ -35400,8 +35462,8 @@ ${exactMatches}`);
   if (syncedTeams.length > 0) {
     sections.push(`Auto-synced shared memories: ${syncedTeams.join(", ")}`);
   }
-  for (const warning of syncWarnings) {
-    sections.push(`Auto-sync warning: ${warning}`);
+  for (const warning2 of syncWarnings) {
+    sections.push(`Auto-sync warning: ${warning2}`);
   }
   if (sections.length <= 1) {
     return semanticResult;
@@ -35499,7 +35561,7 @@ function registerReadTool(server, config2, name, description) {
       }
       const syncMessages = [
         syncedTeams.length > 0 ? `Auto-synced shared memories: ${syncedTeams.join(", ")}` : void 0,
-        ...syncWarnings.map((warning) => `Auto-sync warning: ${warning}`)
+        ...syncWarnings.map((warning2) => `Auto-sync warning: ${warning2}`)
       ].filter((part) => part !== void 0);
       return {
         ...result,
@@ -35547,7 +35609,9 @@ function registerStoreTool(server, config2, name, description) {
       inputSchema: {
         kind: external_exports.enum(["durable", "handoff", "incident", "preference", "smoke"]).optional().describe("Memory lifecycle kind; durable facts and handoffs are most common"),
         project: external_exports.string().optional().describe("Project/repo namespace, for example threadnote or mobile-native"),
-        replaceUri: external_exports.string().optional().describe("Optional viking:// memory URI to forget after the new memory is safely stored"),
+        replaceUri: external_exports.string().optional().describe(
+          "Optional viking:// memory URI to replace. Shared URIs are updated in place and pushed; personal URIs are forgotten after the replacement is safely stored."
+        ),
         text: external_exports.string().optional().describe("Required memory text to store"),
         sourceAgentClient: external_exports.string().optional().describe("Originating client, for example cursor, copilot, codex, or claude"),
         status: external_exports.enum(["active", "archived", "superseded"]).optional().describe("Memory lifecycle status"),
@@ -35866,6 +35930,9 @@ async function readTextIfExists(path) {
 async function writeDurableMemory(config2, params) {
   try {
     const ov = await requiredOpenVikingCli2();
+    if (params.replaceUri && isInSharedNamespace(config2, params.replaceUri)) {
+      return await writeSharedMemoryReplacement(config2, ov, params, params.replaceUri);
+    }
     const directoryUri = memoryDirectoryUri(config2, params.metadata);
     await ensureMemoryDirectory(ov, config2, directoryUri);
     const candidateMetadata = { ...params.metadata, supersedes: params.replaceUri };
@@ -35906,6 +35973,40 @@ async function writeDurableMemory(config2, params) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
+  if (params.metadata.kind !== "durable") {
+    return argumentError("Shared memory replacement only supports durable memories.");
+  }
+  const teamName = sharedTeamNameForUri(config2, targetUri);
+  if (!teamName) {
+    return argumentError(`Memory ${targetUri} is not in the shared namespace.`);
+  }
+  const resolved = await resolveTeam(config2, teamName);
+  const inferred = sharedMemoryUriParts(config2, targetUri);
+  const metadata = {
+    ...params.metadata,
+    project: params.metadata.project ?? inferred?.project,
+    topic: params.metadata.topic ?? inferred?.topic
+  };
+  const rawMemory = formatMemoryDocument2("MEMORY", metadata, params.bodyText);
+  const scrub = applyScrubber(stripPersonalProvenance(rawMemory), { redact: false });
+  if (scrub.blocker) {
+    return argumentError(
+      `Refusing to update shared memory ${targetUri}: possible ${scrub.blocker}. Strip the sensitive value first.`
+    );
+  }
+  await ensureSharedDirectoryChain(config2, ov, targetUri, false, { quiet: true });
+  await writeMemoryFile(config2, ov, targetUri, scrub.cleaned, "replace", false, { quiet: true });
+  const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
+  const messages = [`Updated shared memory: ${targetUri}`];
+  for (const redaction of scrub.redactions) {
+    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
+  }
+  messages.push(
+    ...await gitPublishWorkflow(resolved.config.worktree, relativePath, `share: update ${relativePath}`, true)
+  );
+  return { content: [{ type: "text", text: messages.join("\n") }] };
+}
 async function runOpenVikingWriteWithRetry(ov, config2, memoryUri, args) {
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
@@ -35944,9 +36045,9 @@ async function removeVikingResourceWithRetry(ov, config2, uri) {
   }
   return false;
 }
-function isResourceBusy(stderr, stdout) {
+function isResourceBusy(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed");
 }
 async function ensureMemoryDirectory(ov, config2, directoryUri) {
@@ -36224,11 +36325,11 @@ function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
-  if (!command) {
+  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  if (!command2) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }
-  return command;
+  return command2;
 }
 async function firstExistingPath(paths) {
   for (const path of paths) {

package/dist/threadnote.cjs

@@ -347,11 +347,11 @@ var require_help = __commonJS({
        * @returns {number}
        */
       longestSubcommandTermLength(cmd, helper) {
-        return helper.visibleCommands(cmd).reduce((max, command) => {
+        return helper.visibleCommands(cmd).reduce((max, command2) => {
           return Math.max(
             max,
             this.displayWidth(
-              helper.styleSubcommandTerm(helper.subcommandTerm(command))
+              helper.styleSubcommandTerm(helper.subcommandTerm(command2))
             )
           );
         }, 0);
@@ -512,9 +512,9 @@ var require_help = __commonJS({
        * @param {Help} helper
        * @returns string[]
        */
-      formatItemList(heading, items, helper) {
+      formatItemList(heading2, items, helper) {
         if (items.length === 0) return [];
-        return [helper.styleTitle(heading), ...items, ""];
+        return [helper.styleTitle(heading2), ...items, ""];
       }
       /**
        * Group items by their help group heading.
@@ -993,8 +993,8 @@ var require_option = __commonJS({
        * @param {string} heading
        * @return {Option}
        */
-      helpGroup(heading) {
-        this.helpGroupHeading = heading;
+      helpGroup(heading2) {
+        this.helpGroupHeading = heading2;
         return this;
       }
       /**
@@ -1284,8 +1284,8 @@ var require_command = __commonJS({
        */
       _getCommandAndAncestors() {
         const result = [];
-        for (let command = this; command; command = command.parent) {
-          result.push(command);
+        for (let command2 = this; command2; command2 = command2.parent) {
+          result.push(command2);
         }
         return result;
       }
@@ -1726,22 +1726,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {Command} command
        * @private
        */
-      _registerCommand(command) {
+      _registerCommand(command2) {
         const knownBy = (cmd) => {
           return [cmd.name()].concat(cmd.aliases());
         };
-        const alreadyUsed = knownBy(command).find(
+        const alreadyUsed = knownBy(command2).find(
           (name) => this._findCommand(name)
         );
         if (alreadyUsed) {
           const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-          const newCmd = knownBy(command).join("|");
+          const newCmd = knownBy(command2).join("|");
           throw new Error(
             `cannot add command '${newCmd}' as already have command '${existingCmd}'`
           );
         }
-        this._initCommandGroup(command);
-        this.commands.push(command);
+        this._initCommandGroup(command2);
+        this.commands.push(command2);
       }
       /**
        * Add an option.
@@ -2913,12 +2913,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let suggestion = "";
         if (flag.startsWith("--") && this._showSuggestionAfterError) {
           let candidateFlags = [];
-          let command = this;
+          let command2 = this;
           do {
-            const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
+            const moreFlags = command2.createHelp().visibleOptions(command2).filter((option) => option.long).map((option) => option.long);
             candidateFlags = candidateFlags.concat(moreFlags);
-            command = command.parent;
-          } while (command && !command._enablePositionalOptions);
+            command2 = command2.parent;
+          } while (command2 && !command2._enablePositionalOptions);
           suggestion = suggestSimilar(flag, candidateFlags);
         }
         const message = `error: unknown option '${flag}'${suggestion}`;
@@ -2948,9 +2948,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let suggestion = "";
         if (this._showSuggestionAfterError) {
           const candidateNames = [];
-          this.createHelp().visibleCommands(this).forEach((command) => {
-            candidateNames.push(command.name());
-            if (command.alias()) candidateNames.push(command.alias());
+          this.createHelp().visibleCommands(this).forEach((command2) => {
+            candidateNames.push(command2.name());
+            if (command2.alias()) candidateNames.push(command2.alias());
           });
           suggestion = suggestSimilar(unknownName, candidateNames);
         }
@@ -3021,11 +3021,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       alias(alias) {
         if (alias === void 0) return this._aliases[0];
-        let command = this;
+        let command2 = this;
         if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-          command = this.commands[this.commands.length - 1];
+          command2 = this.commands[this.commands.length - 1];
         }
-        if (alias === command._name)
+        if (alias === command2._name)
           throw new Error("Command alias can't be the same as its name");
         const matchingCommand = this.parent?._findCommand(alias);
         if (matchingCommand) {
@@ -3034,7 +3034,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`
           );
         }
-        command._aliases.push(alias);
+        command2._aliases.push(alias);
         return this;
       }
       /**
@@ -3088,9 +3088,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [heading]
        * @return {Command | string}
        */
-      helpGroup(heading) {
-        if (heading === void 0) return this._helpGroupHeading ?? "";
-        this._helpGroupHeading = heading;
+      helpGroup(heading2) {
+        if (heading2 === void 0) return this._helpGroupHeading ?? "";
+        this._helpGroupHeading = heading2;
         return this;
       }
       /**
@@ -3106,9 +3106,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [heading]
        * @returns {Command | string}
        */
-      commandsGroup(heading) {
-        if (heading === void 0) return this._defaultCommandGroup ?? "";
-        this._defaultCommandGroup = heading;
+      commandsGroup(heading2) {
+        if (heading2 === void 0) return this._defaultCommandGroup ?? "";
+        this._defaultCommandGroup = heading2;
         return this;
       }
       /**
@@ -3124,9 +3124,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [heading]
        * @returns {Command | string}
        */
-      optionsGroup(heading) {
-        if (heading === void 0) return this._defaultOptionGroup ?? "";
-        this._defaultOptionGroup = heading;
+      optionsGroup(heading2) {
+        if (heading2 === void 0) return this._defaultOptionGroup ?? "";
+        this._defaultOptionGroup = heading2;
         return this;
       }
       /**
@@ -3246,7 +3246,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           write: outputContext.write,
           command: this
         };
-        this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+        this._getCommandAndAncestors().reverse().forEach((command2) => command2.emit("beforeAllHelp", eventContext));
         this.emit("beforeHelp", eventContext);
         let helpInformation = this.helpInformation({ error: outputContext.error });
         if (deprecatedCallback) {
@@ -3261,7 +3261,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         this.emit("afterHelp", eventContext);
         this._getCommandAndAncestors().forEach(
-          (command) => command.emit("afterAllHelp", eventContext)
+          (command2) => command2.emit("afterAllHelp", eventContext)
         );
       }
       /**
@@ -3541,6 +3541,83 @@ var import_node_http = require("node:http");
 var import_node_net = require("node:net");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+
+// src/cli_ui.ts
+var import_node_readline = require("node:readline");
+var import_node_process = require("node:process");
+var ANSI = {
+  blue: "\x1B[34m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+function color(name, text) {
+  if (!shouldUseColor()) {
+    return text;
+  }
+  return `${ANSI[name]}${text}${ANSI.reset}`;
+}
+function bold(text) {
+  if (!shouldUseColor()) {
+    return text;
+  }
+  return `${ANSI.bold}${text}${ANSI.reset}`;
+}
+function command(text) {
+  return color("cyan", text);
+}
+function heading(text) {
+  return bold(text);
+}
+function info(text) {
+  return color("cyan", text);
+}
+function muted(text) {
+  return color("dim", text);
+}
+function success(text) {
+  return color("green", text);
+}
+function warning(text) {
+  return color("yellow", text);
+}
+function failure(text) {
+  return color("red", text);
+}
+function keyValue(label, value) {
+  return `${label}: ${value}`;
+}
+function shouldUseColor() {
+  return import_node_process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.CI === void 0 && process.env.TERM !== "dumb";
+}
+async function withSpinner(message, action) {
+  if (import_node_process.stdout.isTTY !== true || process.env.CI !== void 0 || process.env.THREADNOTE_NO_SPINNER !== void 0) {
+    return action();
+  }
+  const frames = ["-", "\\", "|", "/"];
+  let frameIndex = 0;
+  const render = () => {
+    (0, import_node_readline.clearLine)(import_node_process.stdout, 0);
+    (0, import_node_readline.cursorTo)(import_node_process.stdout, 0);
+    import_node_process.stdout.write(`${muted(frames[frameIndex])} ${message}`);
+    frameIndex = (frameIndex + 1) % frames.length;
+  };
+  render();
+  const timer = setInterval(render, 100);
+  try {
+    return await action();
+  } finally {
+    clearInterval(timer);
+    (0, import_node_readline.clearLine)(import_node_process.stdout, 0);
+    (0, import_node_readline.cursorTo)(import_node_process.stdout, 0);
+  }
+}
+
+// src/utils.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3630,11 +3707,11 @@ function escapeRegExp(value) {
   return value.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
 }
 async function requiredOpenVikingCli() {
-  const command = await findExecutable(["ov", "openviking"]);
-  if (!command) {
+  const command2 = await findExecutable(["ov", "openviking"]);
+  if (!command2) {
     throw new Error("Neither ov nor openviking was found in PATH. Run threadnote install first.");
   }
-  return command;
+  return command2;
 }
 async function openVikingCliForMode(dryRun) {
   if (dryRun) {
@@ -3642,16 +3719,16 @@ async function openVikingCliForMode(dryRun) {
   }
   return requiredOpenVikingCli();
 }
-async function requiredExecutable(command) {
-  const executable = await findExecutable([command]);
+async function requiredExecutable(command2) {
+  const executable = await findExecutable([command2]);
   if (!executable) {
-    throw new Error(`${command} was not found in PATH.`);
+    throw new Error(`${command2} was not found in PATH.`);
   }
   return executable;
 }
 async function findExecutable(commands) {
-  for (const command of commands) {
-    const result = await runCommand("which", [command], { allowFailure: true });
+  for (const command2 of commands) {
+    const result = await runCommand("which", [command2], { allowFailure: true });
     if (result.exitCode === 0 && result.stdout.trim()) {
       return result.stdout.trim();
     }
@@ -3660,7 +3737,8 @@ async function findExecutable(commands) {
 }
 async function maybeRun(dryRun, executable, args, options = {}) {
   const cwdSuffix = options.cwd ? ` (cwd: ${options.cwd})` : "";
-  console.log(`${dryRun ? "Would run" : "Running"}: ${formatShellCommand(executable, args)}${cwdSuffix}`);
+  const label = dryRun ? warning("Would run") : info("Running");
+  console.log(`${label}: ${command(formatShellCommand(executable, args))}${cwdSuffix}`);
   if (dryRun) {
     return void 0;
   }
@@ -4090,12 +4168,12 @@ function firstLine(value) {
 }
 function formatStatus(status) {
   if (status === "ok") {
-    return "OK  ";
+    return success("OK  ");
   }
   if (status === "warn") {
-    return "WARN";
+    return warning("WARN");
   }
-  return "FAIL";
+  return failure("FAIL");
 }
 function formatShellCommand(executable, args) {
   return redactText([executable, ...args].map(shellQuote).join(" "));
@@ -4152,7 +4230,7 @@ async function runMcpInstall(config, agent, options) {
     });
     return;
   }
-  const command = buildMcpInstallCommand(config, agent, name, {
+  const command2 = buildMcpInstallCommand(config, agent, name, {
     bearerTokenEnvVar: options.bearerTokenEnvVar,
     nativeHttp,
     scope: options.scope,
@@ -4161,11 +4239,11 @@ async function runMcpInstall(config, agent, options) {
   const removeCommand = buildMcpRemoveCommand(agent, name);
   if (!apply) {
     console.log("Dry run. Re-run with --apply to modify the selected agent config.");
-    if (removeCommand.cwd || command.cwd) {
-      console.log(`Command working directory: ${removeCommand.cwd ?? command.cwd}`);
+    if (removeCommand.cwd || command2.cwd) {
+      console.log(`Command working directory: ${removeCommand.cwd ?? command2.cwd}`);
     }
     console.log(formatShellCommand(removeCommand.executable, removeCommand.args));
-    console.log(formatShellCommand(command.executable, command.args));
+    console.log(formatShellCommand(command2.executable, command2.args));
     printMcpSnippet(config, agent, name, { nativeHttp, scope: options.scope, url });
     return;
   }
@@ -4173,7 +4251,7 @@ async function runMcpInstall(config, agent, options) {
     allowFailure: true,
     cwd: removeCommand.cwd
   });
-  await maybeRun(false, command.executable, command.args, { cwd: command.cwd });
+  await maybeRun(false, command2.executable, command2.args, { cwd: command2.cwd });
 }
 async function runCursorMcpInstall(config, name, options) {
   const path = cursorMcpConfigPath();
@@ -4244,8 +4322,8 @@ async function removeMcpConfigs(value, dryRun) {
       await removeCopilotMcpConfig(OPENVIKING_MCP_NAME, dryRun);
       continue;
     }
-    const command = buildMcpRemoveCommand(client, OPENVIKING_MCP_NAME);
-    await maybeRun(dryRun, command.executable, command.args, { allowFailure: true, cwd: command.cwd });
+    const command2 = buildMcpRemoveCommand(client, OPENVIKING_MCP_NAME);
+    await maybeRun(dryRun, command2.executable, command2.args, { allowFailure: true, cwd: command2.cwd });
   }
 }
 async function removeMcpSnippets(config, dryRun) {
@@ -4280,17 +4358,17 @@ function buildMcpInstallCommand(config, agent, name, options) {
   const claudeCwd = getInvocationCwd();
   const claudeScope = options.scope ?? "user";
   if (!options.nativeHttp) {
-    const command = mcpAdapterCommand();
+    const command2 = mcpAdapterCommand();
     const env = mcpEnvironment(config);
     if (agent === "codex") {
       return {
         executable: "codex",
-        args: ["mcp", "add", ...env.flatMap((value) => ["--env", value]), name, "--", "/usr/bin/env", ...command]
+        args: ["mcp", "add", ...env.flatMap((value) => ["--env", value]), name, "--", "/usr/bin/env", ...command2]
       };
     }
     return {
       executable: "claude",
-      args: ["mcp", "add", "--scope", claudeScope, name, "--", "/usr/bin/env", ...env, ...command],
+      args: ["mcp", "add", "--scope", claudeScope, name, "--", "/usr/bin/env", ...env, ...command2],
       cwd: claudeCwd
     };
   }
@@ -4472,12 +4550,12 @@ function printMcpSnippet(config, agent, name, options) {
     return;
   }
   const snippetPath = (0, import_node_path2.join)(config.agentContextHome, "mcp", `${name}.${agent}.${agent === "codex" ? "toml" : "txt"}`);
-  const command = buildMcpInstallCommand(config, agent, name, {
+  const command2 = buildMcpInstallCommand(config, agent, name, {
     nativeHttp: options.nativeHttp,
     scope: options.scope,
     url: options.url
   });
-  const snippet2 = `${formatShellCommand(command.executable, command.args)}
+  const snippet2 = `${formatShellCommand(command2.executable, command2.args)}
 `;
   console.log(`
 Snippet (${snippetPath}):
@@ -7960,9 +8038,9 @@ async function syncSharedReposBeforeAgentRead(config) {
     const remainingBehind = new Set(state.behindTeams);
     for (const team of syncTeams) {
       try {
-        const warning = await runShareSyncQuiet(config, state, { team });
-        if (warning) {
-          warnings.push(warning);
+        const warning2 = await runShareSyncQuiet(config, state, { team });
+        if (warning2) {
+          warnings.push(warning2);
         } else {
           remainingBehind.delete(team);
           syncedTeams.push(team);
@@ -8510,7 +8588,35 @@ function workfileToVikingUri(config, team, filePath) {
   return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config, uri) {
-  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`);
+  return sharedTeamNameForUri(config, uri) !== void 0;
+}
+function sharedTeamNameForUri(config, uri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team] = uri.slice(prefix.length).split("/");
+  return team || void 0;
+}
+function sharedMemoryUriParts(config, uri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team, kind, scope, project, ...topicParts] = uri.slice(prefix.length).split("/");
+  if (!team) {
+    return void 0;
+  }
+  if (kind !== "durable" || scope !== "projects" || !project || topicParts.length === 0) {
+    return { team };
+  }
+  const topicPath = topicParts.join("/");
+  return {
+    kind,
+    project,
+    team,
+    topic: topicPath.endsWith(".md") ? topicPath.slice(0, -".md".length) : topicPath
+  };
 }
 function isInTeamNamespace(config, uri, team) {
   return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`);
@@ -8696,14 +8802,14 @@ async function waitForOvQueue(ov, config, options = {}) {
     console.error(result.stderr.trim());
   }
 }
-function isTransientOvFailure(stderr, stdout) {
+function isTransientOvFailure(stderr, stdout2) {
   const output2 = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.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");
 }
-function isResourceBusyFailure(stderr, stdout) {
+function isResourceBusyFailure(stderr, stdout2) {
   const output2 = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed");
 }
 async function ingestSingleFile(ov, config, uri, filePath, initialMode, options = {}) {
@@ -9138,8 +9244,8 @@ async function syncSharedReposAndLog(config) {
     if (syncResult.syncedTeams.length > 0) {
       console.error(`Auto-synced shared memories: ${syncResult.syncedTeams.join(", ")}`);
     }
-    for (const warning of syncResult.warnings) {
-      console.error(`Auto-sync warning: ${warning}`);
+    for (const warning2 of syncResult.warnings) {
+      console.error(`Auto-sync warning: ${warning2}`);
     }
   } catch (err) {
     console.error(`Auto-sync warning: ${err instanceof Error ? err.message : String(err)}`);
@@ -9434,6 +9540,10 @@ async function storeMemory(config, options) {
     assertVikingUri(options.replaceUri);
   }
   const ov = await openVikingCliForMode(options.dryRun);
+  if (options.replaceUri && isInSharedNamespace(config, options.replaceUri)) {
+    await storeSharedMemoryReplacement(config, ov, options, options.replaceUri);
+    return;
+  }
   const memoryPath = (0, import_node_path6.join)(config.agentContextHome, "last-memory.txt");
   const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
   const candidateMemory = formatMemoryDocument2(options.title, candidateMetadata, options.bodyText);
@@ -9484,6 +9594,49 @@ async function storeMemory(config, options) {
     console.log(`Updated existing memory in place: ${memoryUri}`);
   }
 }
+async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
+  if (options.metadata.kind !== "durable") {
+    throw new Error("Shared memory replacement only supports durable memories.");
+  }
+  const teamName = sharedTeamNameForUri(config, targetUri);
+  if (!teamName) {
+    throw new Error(`Memory ${targetUri} is not in the shared namespace.`);
+  }
+  const team = await resolveTeam(config, teamName);
+  const inferred = sharedMemoryUriParts(config, targetUri);
+  const metadata = {
+    ...options.metadata,
+    project: options.metadata.project ?? inferred?.project,
+    topic: options.metadata.topic ?? inferred?.topic
+  };
+  const rawMemory = formatMemoryDocument2(options.title, metadata, options.bodyText);
+  const scrub = applyScrubber(stripPersonalProvenance(rawMemory), { redact: false });
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to update shared memory ${targetUri}: possible ${scrub.blocker}. Strip the sensitive value first.`
+    );
+  }
+  const memory = scrub.cleaned;
+  const relativePath = vikingUriToWorktreeRelative(config, targetUri, team.name);
+  if (options.dryRun) {
+    console.log(memory);
+    console.log("\nWould run:");
+  }
+  await ensureSharedDirectoryChain(config, ov, targetUri, options.dryRun);
+  await writeMemoryFile(config, ov, targetUri, memory, "replace", options.dryRun);
+  const git = await requiredExecutable("git");
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "add", "--", relativePath]);
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "commit", "-m", `share: update ${relativePath}`], {
+    allowFailure: true
+  });
+  await maybeRun(options.dryRun, git, ["-C", team.config.worktree, "push", DEFAULT_GIT_REMOTE_NAME], {
+    allowFailure: true
+  });
+  for (const redaction of scrub.redactions) {
+    console.log(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
+  }
+  console.log(`Updated shared memory: ${targetUri}`);
+}
 async function writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode) {
   const args = withIdentity(config, [
     "write",
@@ -9920,9 +10073,9 @@ function localUserMemoriesRoot(config) {
 function uniqueStrings(values) {
   return [...new Set(values)].sort();
 }
-function isResourceBusy(stderr, stdout) {
+function isResourceBusy(stderr, stdout2) {
   const output2 = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed");
 }
 async function buildHandoff(options) {
@@ -10712,7 +10865,7 @@ var import_node_fs6 = require("node:fs");
 var import_promises11 = require("node:fs/promises");
 var import_node_os6 = require("node:os");
 var import_node_path12 = require("node:path");
-var import_node_process2 = require("node:process");
+var import_node_process3 = require("node:process");
 var import_promises12 = require("node:readline/promises");
 
 // src/update.ts
@@ -10721,7 +10874,106 @@ var import_promises9 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
 var import_node_path11 = require("node:path");
 var import_promises10 = require("node:readline/promises");
-var import_node_process = require("node:process");
+var import_node_process2 = require("node:process");
+
+// src/release_notes.ts
+var GITHUB_RELEASES_URL = "https://api.github.com/repos/Kashkovsky/threadnote/releases?per_page=100";
+var RELEASE_FETCH_TIMEOUT_MS = 3500;
+async function fetchThreadnoteReleaseNotes() {
+  const response = await fetch(GITHUB_RELEASES_URL, {
+    headers: {
+      accept: "application/vnd.github+json",
+      "user-agent": "threadnote-cli"
+    },
+    signal: AbortSignal.timeout(RELEASE_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub releases returned HTTP ${response.status}`);
+  }
+  const parsed = await response.json();
+  if (!Array.isArray(parsed)) {
+    throw new Error("GitHub releases response was not an array.");
+  }
+  return parsed.flatMap(parseGithubRelease);
+}
+function releasesBetween(releases, currentVersion, latestVersion) {
+  return releases.filter(
+    (release) => compareVersions(release.version, currentVersion) > 0 && compareVersions(release.version, latestVersion) <= 0
+  ).sort((left, right) => compareVersions(left.version, right.version));
+}
+function releaseForVersion(releases, version) {
+  return releases.filter((release) => compareVersions(release.version, version) === 0).slice(0, 1);
+}
+function formatWhatsNew(releases) {
+  if (releases.length === 0) {
+    return [];
+  }
+  const lines = ["What's new:"];
+  for (const release of releases) {
+    lines.push(`${release.version}: ${release.title || "Release notes"}`);
+    for (const line of bodyLines(release.body)) {
+      lines.push(`  ${line}`);
+    }
+  }
+  return lines;
+}
+async function whatsNewLinesForVersion(version) {
+  try {
+    const releases = await fetchThreadnoteReleaseNotes();
+    const lines = formatWhatsNew(releaseForVersion(releases, version));
+    return lines.length > 0 ? lines : ["What's new:", `No GitHub release notes found for ${version}.`];
+  } catch (err) {
+    return [`What's new: unavailable (${errorMessage(err)})`];
+  }
+}
+async function whatsNewLinesForVersionRange(currentVersion, latestVersion) {
+  try {
+    const releases = await fetchThreadnoteReleaseNotes();
+    const lines = formatWhatsNew(releasesBetween(releases, currentVersion, latestVersion));
+    return lines.length > 0 ? lines : ["What's new:", "No GitHub release notes found for this version range."];
+  } catch (err) {
+    return [`What's new: unavailable (${errorMessage(err)})`];
+  }
+}
+function parseGithubRelease(value) {
+  if (!isJsonObject(value) || value.draft === true || value.prerelease === true) {
+    return [];
+  }
+  const tagName = typeof value.tag_name === "string" ? value.tag_name : "";
+  const version = tagName.trim().replace(/^v/, "");
+  if (!/^\d+\.\d+\.\d+(?:[-.A-Za-z0-9]+)?$/.test(version)) {
+    return [];
+  }
+  const name = typeof value.name === "string" ? value.name : tagName;
+  const body = typeof value.body === "string" ? value.body : "";
+  const url = typeof value.html_url === "string" ? value.html_url : void 0;
+  return [{ body, title: titleFromReleaseName(name, version), url, version }];
+}
+function titleFromReleaseName(name, version) {
+  const trimmed = name.trim();
+  const withoutPrefix = trimmed.replace(new RegExp(`^v?${escapeRegExp2(version)}:\\s*`, "i"), "");
+  return withoutPrefix || trimmed || "Release notes";
+}
+function bodyLines(body) {
+  const out = [];
+  for (const rawLine of body.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || /^#{1,6}\s+/.test(line)) {
+      continue;
+    }
+    if (/^[-*]\s+/.test(line)) {
+      out.push(`- ${line.replace(/^[-*]\s+/, "")}`);
+    } else {
+      out.push(line);
+    }
+  }
+  return out;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+}
+
+// src/update.ts
 var NPM_PACKAGE_NAME = "threadnote";
 var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
 var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -10738,43 +10990,47 @@ async function maybeNotifyUpdate(config, options = {}) {
     return;
   }
   try {
-    const info = await getUpdateInfo(config, {
+    const info2 = await getUpdateInfo(config, {
       allowCacheWrite: options.dryRun !== true,
       preferFresh: false,
       registry: updateRegistry()
     });
-    if (!info.isUpdateAvailable) {
+    if (!info2.isUpdateAvailable) {
       return;
     }
     console.log("");
-    console.log(`Update available: threadnote ${info.currentVersion} -> ${info.latestVersion}`);
-    console.log("Run: threadnote update");
+    console.log(warning(`Update available: threadnote ${info2.currentVersion} -> ${info2.latestVersion}`));
+    console.log(`Run: ${info("threadnote update")}`);
   } catch (_err) {
     return;
   }
 }
 async function runUpdate(config, options) {
   const registry = normalizeRegistry(options.registry ?? updateRegistry());
-  const info = await getUpdateInfo(config, {
-    allowCacheWrite: options.dryRun !== true,
-    preferFresh: true,
-    registry
-  });
-  console.log(`Current version: ${info.currentVersion}`);
-  console.log(`Latest version:  ${info.latestVersion}`);
-  console.log(`Registry:        ${info.registry}`);
+  const info2 = await withSpinner(
+    "Checking npm for latest threadnote version",
+    () => getUpdateInfo(config, {
+      allowCacheWrite: options.dryRun !== true,
+      preferFresh: true,
+      registry
+    })
+  );
+  console.log(keyValue("Current version", info(info2.currentVersion)));
+  console.log(keyValue("Latest version", info(info2.latestVersion)));
+  console.log(keyValue("Registry", info2.registry));
   if (options.check === true) {
-    if (info.isUpdateAvailable) {
-      console.log(`Update available. Run: threadnote update`);
+    if (info2.isUpdateAvailable) {
+      console.log(warning("Update available. Run: threadnote update"));
+      await printWhatsNewIfAvailable(info2);
     } else {
       console.log(
-        compareVersions(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
+        compareVersions(info2.currentVersion, info2.latestVersion) > 0 ? warning("Current version is newer than npm latest.") : success("Threadnote is up to date.")
       );
     }
     return;
   }
-  if (!info.isUpdateAvailable && options.force !== true) {
-    console.log("Threadnote is up to date.");
+  if (!info2.isUpdateAvailable && options.force !== true) {
+    console.log(success("Threadnote is up to date."));
     return;
   }
   const runtime = await resolveUpdateRuntime(options.runtime ?? "auto");
@@ -10782,6 +11038,7 @@ async function runUpdate(config, options) {
   await maybeRun(options.dryRun === true, updateCommand.executable, updateCommand.args);
   if (options.repair === false) {
     console.log("Skipping repair because --no-repair was provided.");
+    await printWhatsNewIfAvailable(info2);
     return;
   }
   const threadnoteCommand = await installedThreadnoteCommand(runtime);
@@ -10790,9 +11047,9 @@ async function runUpdate(config, options) {
     const postUpdateArgs = [
       "post-update",
       "--from-version",
-      info.currentVersion,
+      info2.currentVersion,
       "--to-version",
-      info.latestVersion,
+      info2.latestVersion,
       ...options.yes === true ? ["--yes"] : []
     ];
     if (options.dryRun === true) {
@@ -10810,6 +11067,20 @@ async function runUpdate(config, options) {
   console.log(
     "Update complete. Restart Cursor, Copilot, Codex, Claude, or open a fresh agent session so MCP tools reload."
   );
+  await printWhatsNewIfAvailable(info2);
+}
+async function printWhatsNewIfAvailable(info2) {
+  if (!info2.isUpdateAvailable) {
+    return;
+  }
+  console.log("");
+  const whatsNew = await withSpinner(
+    "Fetching GitHub release notes",
+    () => whatsNewLinesForVersionRange(info2.currentVersion, info2.latestVersion)
+  );
+  for (const line of whatsNew) {
+    console.log(line === "What's new:" ? heading(line) : line);
+  }
 }
 async function runPostUpdate(config, options) {
   if (!options.fromVersion || !options.toVersion) {
@@ -11127,7 +11398,7 @@ function printPostUpdateMigration(migration) {
   }
 }
 async function confirmPostUpdateMigration(prompt, defaultYes = false) {
-  const readline = (0, import_promises10.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  const readline = (0, import_promises10.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
   try {
     const answer = (await readline.question(prompt)).trim().toLowerCase();
     if (answer === "") {
@@ -11649,8 +11920,8 @@ async function commandPresenceCheck(name, args) {
   };
 }
 async function firstCommandCheck(name, commands, args) {
-  for (const command of commands) {
-    const executable = await findExecutable([command]);
+  for (const command2 of commands) {
+    const executable = await findExecutable([command2]);
     if (!executable) {
       continue;
     }
@@ -11658,7 +11929,7 @@ async function firstCommandCheck(name, commands, args) {
     return {
       name,
       status: result.exitCode === 0 ? "ok" : "warn",
-      detail: `${command}: ${firstLine(result.stdout || result.stderr) || executable}`
+      detail: `${command2}: ${firstLine(result.stdout || result.stderr) || executable}`
     };
   }
   return { name, status: "fail", detail: `none found: ${commands.join(", ")}` };
@@ -11833,13 +12104,13 @@ async function runInstallCommands(config, preferred, force, dryRun) {
   }
 }
 async function offerToInstallUv() {
-  if (import_node_process2.stdin.isTTY !== true || import_node_process2.stdout.isTTY !== true) {
+  if (import_node_process3.stdin.isTTY !== true || import_node_process3.stdout.isTTY !== true) {
     console.warn(
       "Neither uv nor pipx was found on PATH. Falling back to `python3 -m pip install --user`, which fails on PEP 668 (Homebrew/system) Python.\nRe-run with --package-manager uv after installing uv (brew install uv), or pass --package-manager pipx."
     );
     return false;
   }
-  const readline = (0, import_promises12.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+  const readline = (0, import_promises12.createInterface)({ input: import_node_process3.stdin, output: import_node_process3.stdout });
   let answer;
   try {
     answer = (await readline.question(
@@ -12290,6 +12561,46 @@ function parsePackageManager(value) {
   throw new Error(`Invalid package manager: ${value}`);
 }
 
+// src/version_command.ts
+async function runVersion(config, options) {
+  const currentVersion = await currentPackageVersion();
+  const registry = normalizeRegistry(options.registry ?? updateRegistry());
+  let latestVersion;
+  let latestWarning;
+  try {
+    latestVersion = await withSpinner("Checking npm for latest threadnote version", () => fetchLatestVersion2(registry));
+  } catch (err) {
+    latestWarning = errorMessage(err);
+  }
+  console.log(keyValue("Current version", info(currentVersion)));
+  console.log(keyValue("Latest version", latestVersion ? info(latestVersion) : warning("unavailable")));
+  if (latestWarning) {
+    console.log(warning(`Warning: ${latestWarning}`));
+  }
+  if (!latestVersion) {
+    return;
+  }
+  const comparison = compareVersions(currentVersion, latestVersion);
+  if (comparison >= 0) {
+    console.log(success(comparison > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."));
+    console.log("");
+    const whatsNew2 = await withSpinner("Fetching GitHub release notes", () => whatsNewLinesForVersion(currentVersion));
+    printWhatsNew(whatsNew2);
+    return;
+  }
+  console.log("");
+  const whatsNew = await withSpinner(
+    "Fetching GitHub release notes",
+    () => whatsNewLinesForVersionRange(currentVersion, latestVersion)
+  );
+  printWhatsNew(whatsNew);
+}
+function printWhatsNew(whatsNew) {
+  for (const line of whatsNew) {
+    console.log(line === "What's new:" ? heading(line) : line);
+  }
+}
+
 // src/threadnote.ts
 async function main() {
   const program2 = new Command();
@@ -12315,6 +12626,9 @@ async function main() {
     }
     await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
   });
+  program2.command("version").description("Print the installed Threadnote version, latest npm version, and release notes").option("--registry <url>", "npm registry URL", process.env.THREADNOTE_NPM_REGISTRY).action(async (options) => {
+    await runVersion(getRuntimeConfig(program2), options);
+  });
   program2.command("update").description("Update the published Threadnote package, then repair local shims and MCP config").option("--check", "Only check whether a newer version is available").option("--dry-run", "Print update and repair commands without running them").option("--force", "Run package-manager update even if this version is already current").option("--registry <url>", "npm registry URL", process.env.THREADNOTE_NPM_REGISTRY).option("--runtime <runtime>", "auto, npm, bun, or deno", parseUpdateRuntime, "auto").option("--no-repair", "Skip threadnote repair after updating the package").option("--no-post-update", "Skip post-update migration prompts").option("--yes", "Accept applicable post-update migrations without prompting").action(async (options) => {
     await runUpdate(getRuntimeConfig(program2), options);
   });

package/docs/agent-instructions.md

@@ -73,14 +73,17 @@ For branch feature work, prefer two stable memories with the same project and to
 - `kind: handoff` for current status, files touched, tests, blockers, and next step.
 
 If a durable feature memory already exists, update it in place with the same project/topic or with `--replace <uri>` /
-`replaceUri`. Avoid creating a new timestamped durable memory for every small progress note.
+`replaceUri`. When `replaceUri` points at a shared `durable/` URI, Threadnote updates that shared memory in place and
+pushes the shared repo; do not create a personal replacement and then run `share_publish` again. Avoid creating a new
+timestamped durable memory for every small progress note.
 
 ## Memory Compaction
 
 When working on the same active issue, prefer keeping one current-state memory updated instead of creating many small
 progress memories. If an existing memory is clearly the current state for the issue, store the updated version with
 `remember_context({"text":"...","replaceUri":"<uri>"})`, `threadnote remember --replace <uri>`, or
-`threadnote handoff --replace <uri>` so the old memory is removed only after the replacement is stored.
+`threadnote handoff --replace <uri>` so the old personal memory is removed only after the replacement is stored. Shared
+`durable/` replacements are updated in place and pushed instead.
 
 When the issue has a stable name, prefer project/topic storage over timestamped memories:
 

package/docs/index.html

@@ -1341,7 +1341,7 @@ threadnote remember \
               <p class="muted" style="font-size: 0.9rem; margin-top: 0.6rem">
                 Refuses to publish if the memory matches secret patterns (PEM, <code>sk-</code>, <code>gh*_</code>,
                 <code>github_pat_</code>, <code>glpat-</code>, JWTs, AWS keys, Slack tokens). Refuses to silently
-                overwrite an existing shared URI.
+                overwrite an existing shared URI; update shared memories with <code>remember --replace</code>.
               </p>
             </div>
 

package/docs/share.md

@@ -71,6 +71,21 @@ lines from the memory's header block. Those pointers only resolve on the
 publisher's machine — teammates pull via git and cannot dereference them — so
 keeping them would just leak local-only provenance into team git history.
 
+To update an existing shared durable memory, replace the shared URI directly:
+
+```bash
+threadnote remember \
+  --replace viking://user/you/memories/shared/default/durable/projects/foo/bar.md \
+  --project foo \
+  --topic bar \
+  --text "Updated shared knowledge."
+```
+
+For MCP, pass the same shared URI as `replaceUri` to `remember_context`.
+Threadnote rewrites the shared memory in place, strips local-only provenance
+headers, commits, and pushes the shared repo. You do not need to store a
+personal replacement and run `share publish` again.
+
 ### Keep teammates' updates current
 
 Threadnote does a periodic background `git fetch` for configured share teams.
@@ -155,7 +170,9 @@ otherwise unpublished work is lost.
   keep both, copy the memory to a new URI first (`ov read` then
   `threadnote remember`).
 - `share publish` refuses to overwrite an existing shared memory at the same
-  URI; forget the existing shared copy first or pick a different topic name.
+  URI; use `threadnote remember --replace <shared-uri>` or
+  `remember_context({replaceUri:"<shared-uri>"})` for updates, or pick a
+  different topic name.
 
 ## Conflict resolution
 

package/package.json

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