threadnote 0.7.7 → 0.7.9

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;
   }
@@ -3678,33 +3756,111 @@ async function runCommand(executable, args, options = {}) {
     const child = (0, import_node_child_process.spawn)(executable, args, { cwd: options.cwd });
     const stdoutChunks = [];
     const stderrChunks = [];
+    const maxOutputBytes = options.maxOutputBytes ?? defaultCommandMaxOutputBytes();
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let finished = false;
+    let failureResult;
+    let killTimer;
+    let sentTerminationSignal = false;
+    const timeoutMs = options.timeoutMs ?? defaultCommandTimeoutMs();
+    const finish = (result) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      if (result.exitCode !== 0 && options.allowFailure !== true) {
+        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
+        return;
+      }
+      resolvePromise(result);
+    };
+    const failAndKill = (message) => {
+      if (failureResult) {
+        return;
+      }
+      failureResult = { exitCode: 124, stderr: message, stdout: stdoutChunks.join("") };
+      if (!sentTerminationSignal) {
+        sentTerminationSignal = true;
+        child.kill("SIGTERM");
+      }
+      setTimeout(() => {
+        if (!finished) {
+          child.kill("SIGKILL");
+        }
+      }, 1e3).unref?.();
+    };
+    if (timeoutMs > 0) {
+      killTimer = setTimeout(() => {
+        failAndKill(`${formatShellCommand(executable, args)} timed out after ${timeoutMs}ms`);
+      }, timeoutMs);
+      killTimer.unref?.();
+    }
     child.stdout.on("data", (chunk) => {
-      stdoutChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stdoutBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stdoutChunks.push(text);
     });
     child.stderr.on("data", (chunk) => {
-      stderrChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stderrBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stderrChunks.push(text);
     });
     child.on("error", (err) => {
+      if (finished) {
+        return;
+      }
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
       if (options.allowFailure === true) {
-        resolvePromise({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
+        finish({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
       } else {
+        finished = true;
         rejectPromise(err);
       }
     });
     child.on("close", (code) => {
-      const result = {
+      const result = failureResult ?? {
         exitCode: code ?? 1,
         stderr: stderrChunks.join(""),
         stdout: stdoutChunks.join("")
       };
-      if (result.exitCode !== 0 && options.allowFailure !== true) {
-        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
-        return;
-      }
-      resolvePromise(result);
+      finish(result);
     });
   });
 }
+function defaultCommandTimeoutMs() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_TIMEOUT_MS") ?? 10 * 60 * 1e3;
+}
+function defaultCommandMaxOutputBytes() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_MAX_OUTPUT_BYTES") ?? 5 * 1024 * 1024;
+}
+function positiveIntegerFromEnv(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
 async function gitValue(args, cwd = getInvocationCwd()) {
   const result = await runCommand("git", args, { allowFailure: true, cwd });
   if (result.exitCode !== 0) {
@@ -4090,12 +4246,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 +4308,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 +4317,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 +4329,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 +4400,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 +4436,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 +4628,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 +8116,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);
@@ -8156,7 +8312,14 @@ Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or
     }
   }
   if (options.push !== false) {
-    await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+    const pushResult = dryRun ? void 0 : await runCommand(git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+    if (dryRun) {
+      console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME])}`);
+    } else if (pushResult && pushResult.exitCode !== 0) {
+      throw new Error(
+        `git push failed in ${worktree}: ${pushResult.stderr.trim() || pushResult.stdout.trim() || "unknown error"}`
+      );
+    }
   }
 }
 async function runShareSyncQuiet(config, state, options) {
@@ -8204,6 +8367,58 @@ async function stageShareableChanges(dryRun, git, worktree) {
   const pathspecs = [":(top)README.md", ":(top).gitignore", ...SHAREABLE_MEMORY_KIND_DIRS.map((dir) => `:(top)${dir}`)];
   await maybeRun(dryRun, git, ["-C", worktree, "add", "--", ...pathspecs], { allowFailure: true });
 }
+async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
+  const dryRun = options.dryRun === true;
+  const push = options.push !== false;
+  const verb = options.verb ?? "add";
+  const git = await requiredExecutable("git");
+  const messages = [];
+  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", relativePath] : ["-C", worktree, "add", "--", relativePath];
+  const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
+  if (stageResult) {
+    messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
+  }
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "commit", "-m", commitMessage])}`);
+  } else {
+    const commitResult = await runCommand(git, ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
+    if (commitResult.exitCode !== 0) {
+      const detail = commitResult.stdout.trim() || commitResult.stderr.trim();
+      if (/nothing to commit|no changes added/i.test(detail)) {
+        messages.push("git commit: nothing to commit (file already in tree)");
+      } else {
+        throw new Error(`git commit failed: ${detail || "unknown error"}`);
+      }
+    } else {
+      messages.push(`git commit: ${commitResult.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
+    }
+  }
+  if (!push) {
+    messages.push("git push skipped (push=false)");
+    return messages;
+  }
+  const pushResult = await runGitCommand(
+    dryRun,
+    git,
+    ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME],
+    "git push failed"
+  );
+  if (pushResult) {
+    messages.push(`git push: ${pushResult.stdout.trim() || pushResult.stderr.trim() || "ok"}`);
+  }
+  return messages;
+}
+async function runGitCommand(dryRun, git, args, failureLabel) {
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, args)}`);
+    return void 0;
+  }
+  const result = await runCommand(git, args, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    throw new Error(`${failureLabel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+  }
+  return result;
+}
 async function runSharePublish(config, sourceUri, options) {
   assertVikingUri(sourceUri);
   const team = await resolveTeam(config, options.team);
@@ -8250,24 +8465,24 @@ async function runSharePublish(config, sourceUri, options) {
   }
   await ensureSharedDirectoryChain(config, ov, targetUri, dryRun);
   await writeMemoryFile(config, ov, targetUri, content, "create", dryRun);
-  await removeWithRollback(config, ov, sourceUri, targetUri, team.config.worktree, dryRun, "publish");
-  const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const relativePath = vikingUriToWorktreeRelative(config, targetUri, team.name);
   const message = options.message ?? `share: publish ${relativePath}`;
-  await maybeRun(dryRun, git, ["-C", worktree, "add", "--", relativePath]);
-  await maybeRun(dryRun, git, ["-C", worktree, "commit", "-m", message], { allowFailure: true });
-  if (options.push !== false) {
-    const pushResult = dryRun ? void 0 : await runCommand(git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
-    if (dryRun) {
-      console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME])}`);
-    } else if (pushResult && pushResult.exitCode !== 0) {
-      const detail = pushResult.stderr.trim() || pushResult.stdout.trim() || "unknown error";
-      throw new Error(
-        `Memory was committed locally but git push failed: ${detail}
-Resolve the remote issue (auth, network, branch protection), then run: threadnote share sync`
-      );
-    }
+  const gitMessages = await publishShareGitChange(worktree, relativePath, message, {
+    dryRun,
+    push: options.push
+  });
+  for (const gitMessage of gitMessages) {
+    console.log(gitMessage);
+  }
+  try {
+    await removeMemoryUri(config, ov, sourceUri, dryRun);
+  } catch (err) {
+    throw new Error(
+      `Published ${sourceUri} -> ${targetUri}, but could not remove the personal source. Retry cleanup later with: threadnote forget ${sourceUri}
+${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
   }
   console.log(`Published ${sourceUri} -> ${targetUri}`);
 }
@@ -8287,15 +8502,25 @@ async function runShareUnpublish(config, sourceUri, options) {
     );
   }
   await writeMemoryFile(config, ov, targetUri, content, "create", dryRun);
-  await removeWithRollback(config, ov, sourceUri, targetUri, team.config.worktree, dryRun, "unpublish");
-  const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const relativePath = vikingUriToWorktreeRelative(config, sourceUri, team.name);
   const message = options.message ?? `share: unpublish ${relativePath}`;
-  await maybeRun(dryRun, git, ["-C", worktree, "rm", relativePath], { allowFailure: true });
-  await maybeRun(dryRun, git, ["-C", worktree, "commit", "-m", message], { allowFailure: true });
-  if (options.push !== false) {
-    await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+  const gitMessages = await publishShareGitChange(worktree, relativePath, message, {
+    dryRun,
+    push: options.push,
+    verb: "rm"
+  });
+  for (const gitMessage of gitMessages) {
+    console.log(gitMessage);
+  }
+  try {
+    await removeMemoryUri(config, ov, sourceUri, dryRun);
+  } catch (err) {
+    throw new Error(
+      `Unpublished ${sourceUri} -> ${targetUri}, but could not remove the shared OpenViking source. Retry cleanup later with: threadnote forget ${sourceUri}
+${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
   }
   console.log(`Unpublished ${sourceUri} -> ${targetUri}`);
 }
@@ -8315,9 +8540,98 @@ async function runShareList(config, _options) {
     console.log(`    added: ${team.addedAt}`);
   }
 }
+async function runShareRename(config, options) {
+  const oldTeam = await resolveTeam(config, options.team);
+  const newName = normalizeTeamName(options.to);
+  if (newName === oldTeam.name) {
+    throw new Error(`Team is already named "${newName}".`);
+  }
+  const dryRun = options.dryRun === true;
+  const teamsFile = await readTeamsFile(config);
+  if (teamsFile.teams[newName]) {
+    throw new Error(`Team "${newName}" is already configured.`);
+  }
+  const newWorktree = teamWorktreePath(config, newName);
+  const newGitdir = teamGitdirPath(config, newName);
+  await assertDestinationAbsent(newWorktree, "worktree");
+  await assertDestinationAbsent(newGitdir, "gitdir");
+  const updatedTeam = {
+    ...oldTeam.config,
+    gitdir: newGitdir,
+    name: newName,
+    worktree: newWorktree
+  };
+  const updatedTeams = {};
+  for (const [name, value] of Object.entries(teamsFile.teams)) {
+    if (name === oldTeam.name) {
+      updatedTeams[newName] = updatedTeam;
+    } else {
+      updatedTeams[name] = value;
+    }
+  }
+  const updatedFile = {
+    defaultTeam: teamsFile.defaultTeam === oldTeam.name ? newName : teamsFile.defaultTeam,
+    teams: updatedTeams,
+    version: TEAMS_FILE_VERSION
+  };
+  if (dryRun) {
+    console.log(`Would rename worktree: ${portablePath(oldTeam.config.worktree)} -> ${portablePath(newWorktree)}`);
+    console.log(`Would rename gitdir: ${portablePath(oldTeam.config.gitdir)} -> ${portablePath(newGitdir)}`);
+    console.log(`Would update git core.worktree for team "${newName}".`);
+    console.log(`Would reindex shared memories under team "${newName}" and remove old shared URI tree.`);
+    console.log(`Would write teams file: ${teamsFilePath(config)}`);
+    return;
+  }
+  await (0, import_promises4.rename)(oldTeam.config.worktree, newWorktree);
+  await (0, import_promises4.rename)(oldTeam.config.gitdir, newGitdir);
+  await writeTeamsFile(config, updatedFile);
+  const git = await requiredExecutable("git");
+  await runCommand(git, ["-C", newWorktree, "config", "core.worktree", newWorktree]);
+  const ingested = await ingestWorktreeFiles(config, updatedTeam, "replace");
+  const ov = await openVikingCliForMode(false);
+  await removeMemoryUri(
+    config,
+    ov,
+    `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${oldTeam.name}`,
+    false
+  );
+  console.log(`Renamed shared team "${oldTeam.name}" -> "${newName}".`);
+  console.log(`Reindexed ${ingested} shared memory file(s).`);
+}
+async function runShareSetUrl(config, remoteUrl, options) {
+  if (!remoteUrl.trim()) {
+    throw new Error("Provide a git remote URL.");
+  }
+  const team = await resolveTeam(config, options.team);
+  const dryRun = options.dryRun === true;
+  const git = await requiredExecutable("git");
+  if (dryRun) {
+    console.log(
+      `Would run: ${formatShellCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, remoteUrl])}`
+    );
+    console.log(
+      `Would run: ${formatShellCommand(git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME])}`
+    );
+    console.log(`Would write teams file: ${teamsFilePath(config)}`);
+    return;
+  }
+  await runCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, remoteUrl]);
+  await runCommand(git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME]);
+  const teamsFile = await readTeamsFile(config);
+  const updatedTeam = { ...team.config, remote: remoteUrl };
+  await writeTeamsFile(config, {
+    ...teamsFile,
+    teams: { ...teamsFile.teams, [team.name]: updatedTeam }
+  });
+  console.log(`Updated shared team "${team.name}" remote: ${remoteUrl}`);
+}
 async function runShareRemove(config, options) {
   const team = await resolveTeam(config, options.team);
   const dryRun = options.dryRun === true;
+  if (options.preserveLocal === true) {
+    const preserved = await preserveSharedMemoriesLocally(config, team.config, dryRun);
+    console.log(`${dryRun ? "Would preserve" : "Preserved"} ${preserved} shared durable memory file(s) locally.`);
+  }
   const teamsFile = await readTeamsFile(config);
   const remaining = {};
   for (const [name, value] of Object.entries(teamsFile.teams)) {
@@ -8341,6 +8655,47 @@ async function runShareRemove(config, options) {
     console.log(`Keeping files at ${portablePath(team.config.worktree)} and ${portablePath(team.config.gitdir)}`);
   }
 }
+async function assertDestinationAbsent(path, label) {
+  if (await exists(path)) {
+    throw new Error(`Cannot rename share: destination ${label} already exists at ${path}.`);
+  }
+}
+async function preserveSharedMemoriesLocally(config, team, dryRun) {
+  const ov = await openVikingCliForMode(dryRun);
+  const files = await walkMemoryFiles(team.worktree);
+  let preserved = 0;
+  for (const file of files) {
+    const rel = (0, import_node_path5.relative)(team.worktree, file).split(import_node_path5.sep).join("/");
+    if (!rel.startsWith("durable/")) {
+      continue;
+    }
+    const targetUri = `viking://user/${uriSegment(config.user)}/memories/${rel}`;
+    const content = await (0, import_promises4.readFile)(file, "utf8");
+    if (dryRun) {
+      console.log(`Would preserve ${rel} -> ${targetUri}`);
+    } else {
+      await ensurePersonalDirectoryChain(config, ov, parentUri(targetUri));
+      await writeMemoryFile(config, ov, targetUri, content, "create", false);
+    }
+    preserved += 1;
+  }
+  return preserved;
+}
+async function ensurePersonalDirectoryChain(config, ov, directoryUri) {
+  const prefix = "viking://";
+  const parts = directoryUri.startsWith(prefix) ? directoryUri.slice(prefix.length).split("/").filter(Boolean) : [];
+  const startIndex = parts[0] === "user" && parts.length > 2 ? 3 : 1;
+  for (let index = startIndex; index <= parts.length; index += 1) {
+    const uri = `${prefix}${parts.slice(0, index).join("/")}`;
+    const statResult = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+    if (statResult.exitCode !== 0) {
+      await runCommand(
+        ov,
+        withIdentity(config, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
+      );
+    }
+  }
+}
 function normalizeTeamName(input2) {
   const candidate = (input2 ?? "default").trim();
   if (!candidate) {
@@ -8724,61 +9079,20 @@ 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 = {}) {
   const content = await (0, import_promises4.readFile)(filePath, "utf8");
   await writeMemoryFile(config, ov, uri, content, initialMode, false, options);
 }
-async function removeWithRollback(config, ov, sourceUri, rollbackUri, worktree, dryRun, label) {
-  try {
-    await removeMemoryUri(config, ov, sourceUri, dryRun);
-  } catch (sourceErr) {
-    if (dryRun) {
-      throw sourceErr;
-    }
-    console.error(
-      `Source removal failed during ${label}; rolling back ${rollbackUri} so the system is back to the pre-${label} state.`
-    );
-    try {
-      await removeMemoryUri(config, ov, rollbackUri, false);
-    } catch (rollbackErr) {
-      console.error(
-        `Rollback of ${rollbackUri} also failed. Manual cleanup needed via: threadnote forget ${rollbackUri}
-Rollback error: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`
-      );
-    }
-    await bestEffortRemoveWorktreeFile(rollbackUri, worktree, label);
-    throw sourceErr;
-  }
-}
-async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
-  if (label !== "publish") {
-    return;
-  }
-  const prefix = "viking://";
-  if (!rollbackUri.startsWith(prefix)) {
-    return;
-  }
-  const parts = rollbackUri.slice(prefix.length).split("/");
-  const sharedIndex = parts.indexOf("shared");
-  if (sharedIndex === -1 || sharedIndex + 2 >= parts.length) {
-    return;
-  }
-  const relative3 = parts.slice(sharedIndex + 2).join("/");
-  if (!relative3) {
-    return;
-  }
-  await (0, import_promises4.rm)((0, import_node_path5.join)(worktree, relative3), { force: true });
-}
 async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config, ["rm", uri]);
   if (dryRun) {
@@ -9166,8 +9480,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)}`);
@@ -9308,11 +9622,11 @@ function localMemoryPathForUri(config, uri) {
   if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
     return void 0;
   }
-  const relative3 = uri.slice(prefix.length);
-  if (relative3.includes("..") || relative3.startsWith("/")) {
+  const relative4 = uri.slice(prefix.length);
+  if (relative4.includes("..") || relative4.startsWith("/")) {
     return void 0;
   }
-  return (0, import_node_path6.join)(localUserMemoriesRoot(config), ...relative3.split("/"));
+  return (0, import_node_path6.join)(localUserMemoriesRoot(config), ...relative4.split("/"));
 }
 async function runList(config, uri, options) {
   assertVikingUri(uri);
@@ -9546,62 +9860,20 @@ async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
   }
   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
+  const gitMessages = await publishShareGitChange(team.config.worktree, relativePath, `share: update ${relativePath}`, {
+    dryRun: options.dryRun
   });
+  for (const message of gitMessages) {
+    console.log(message);
+  }
   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",
-    memoryUri,
-    "--from-file",
-    memoryPath,
-    "--mode",
-    writeMode,
-    "--wait",
-    "--timeout",
-    "120"
-  ]);
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    console.log(`${attempt === 0 ? "Running" : "Retrying"}: ${formatShellCommand(ov, args)}`);
-    const result = await runCommand(ov, args, { allowFailure: true });
-    if (result.exitCode === 0) {
-      if (result.stdout.trim()) {
-        console.log(result.stdout.trim());
-      }
-      if (result.stderr.trim()) {
-        console.error(result.stderr.trim());
-      }
-      return;
-    }
-    if (await vikingResourceExists2(ov, config, memoryUri)) {
-      console.log("OpenViking accepted the memory but returned before the wait completed; waiting for indexing.");
-      await waitForOpenVikingQueue(ov, config);
-      return;
-    }
-    if (!isResourceBusy(result.stderr, result.stdout) || attempt === 3) {
-      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
-    }
-    await sleep(1e3 * (attempt + 1));
-  }
-}
-async function waitForOpenVikingQueue(ov, config) {
-  const result = await runCommand(ov, withIdentity(config, ["wait", "--timeout", "120"]), { allowFailure: true });
-  if (result.stdout.trim()) {
-    console.log(result.stdout.trim());
-  }
-  if (result.stderr.trim()) {
-    console.error(result.stderr.trim());
-  }
+  const content = await (0, import_promises5.readFile)(memoryPath, "utf8");
+  await writeMemoryFile(config, ov, memoryUri, content, writeMode, false);
 }
 async function removeVikingResourceWithRetry(ov, config, uri) {
   const args = withIdentity(config, ["rm", uri]);
@@ -9628,8 +9900,8 @@ async function removeVikingResourceWithRetry(ov, config, uri) {
   return false;
 }
 async function vikingResourceExists2(ov, config, uri) {
-  const stat4 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-  return stat4.exitCode === 0;
+  const stat5 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+  return stat5.exitCode === 0;
 }
 async function ensureDurableMemoryDirectory(ov, config) {
   await ensureMemoryDirectory(ov, config, durableMemoryDirectoryUri(config));
@@ -9995,9 +10267,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) {
@@ -10787,7 +11059,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
@@ -10796,60 +11068,163 @@ 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 NPM_PACKAGE_NAME = "threadnote";
-var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
-var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
-var POST_UPDATE_MIGRATIONS_FILE = "post-update-migrations.json";
-var POST_UPDATE_STATE_FILE = "post-update-state.json";
-function parseUpdateRuntime(value) {
-  if (value === "auto" || value === "npm" || value === "bun" || value === "deno") {
-    return value;
+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}`);
   }
-  throw new Error(`Invalid update runtime: ${value}. Expected auto, npm, bun, or deno.`);
+  const parsed = await response.json();
+  if (!Array.isArray(parsed)) {
+    throw new Error("GitHub releases response was not an array.");
+  }
+  return parsed.flatMap(parseGithubRelease);
 }
-async function maybeNotifyUpdate(config, options = {}) {
-  if (isUpdateNotificationDisabled()) {
-    return;
+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 [];
   }
-  try {
-    const info = await getUpdateInfo(config, {
-      allowCacheWrite: options.dryRun !== true,
-      preferFresh: false,
-      registry: updateRegistry()
-    });
-    if (!info.isUpdateAvailable) {
-      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;
+var POST_UPDATE_MIGRATIONS_FILE = "post-update-migrations.json";
+var POST_UPDATE_STATE_FILE = "post-update-state.json";
+function parseUpdateRuntime(value) {
+  if (value === "auto" || value === "npm" || value === "bun" || value === "deno") {
+    return value;
+  }
+  throw new Error(`Invalid update runtime: ${value}. Expected auto, npm, bun, or deno.`);
+}
+async function maybeNotifyUpdate(config, options = {}) {
+  if (isUpdateNotificationDisabled()) {
+    return;
+  }
+  try {
+    const info2 = await getUpdateInfo(config, {
+      allowCacheWrite: options.dryRun !== true,
+      preferFresh: false,
+      registry: updateRegistry()
+    });
+    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");
@@ -10857,6 +11232,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);
@@ -10865,9 +11241,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) {
@@ -10885,6 +11261,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) {
@@ -11202,7 +11592,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 === "") {
@@ -11318,6 +11708,19 @@ function isUpdateNotificationDisabled() {
 
 // src/lifecycle.ts
 async function runDoctor(config, options) {
+  const checks = await collectDoctorChecks(config, options);
+  for (const check of checks) {
+    console.log(`${formatStatus(check.status)} ${check.name}: ${check.detail}`);
+  }
+  const failureCount = checks.filter((check) => check.status === "fail").length;
+  const warningCount = checks.filter((check) => check.status === "warn").length;
+  console.log(`
+Summary: ${failureCount} failure(s), ${warningCount} warning(s)`);
+  if (options.strict === true && failureCount > 0) {
+    process.exitCode = 1;
+  }
+}
+async function collectDoctorChecks(config, options = {}) {
   const checks = [];
   checks.push({ name: "mode", status: "ok", detail: options.dryRun ? "dry run; no writes" : "read-only checks" });
   checks.push({ name: "platform", status: (0, import_node_os6.platform)() === "darwin" ? "ok" : "warn", detail: (0, import_node_os6.platform)() });
@@ -11337,16 +11740,7 @@ async function runDoctor(config, options) {
   checks.push(await fileCheck((0, import_node_path12.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
   checks.push(await fileCheck((0, import_node_path12.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}`);
-  }
-  const failureCount = checks.filter((check) => check.status === "fail").length;
-  const warningCount = checks.filter((check) => check.status === "warn").length;
-  console.log(`
-Summary: ${failureCount} failure(s), ${warningCount} warning(s)`);
-  if (options.strict === true && failureCount > 0) {
-    process.exitCode = 1;
-  }
+  return checks;
 }
 async function runInstall(config, options) {
   const repairInvalidConfigs = options.repairInvalidConfigs === true;
@@ -11724,8 +12118,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;
     }
@@ -11733,7 +12127,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(", ")}` };
@@ -11908,13 +12302,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(
@@ -12365,10 +12759,1028 @@ 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/manager.ts
+var import_node_http2 = require("node:http");
+var import_node_crypto2 = require("node:crypto");
+var import_promises13 = require("node:fs/promises");
+var import_node_os7 = require("node:os");
+var import_node_path13 = require("node:path");
+var STATIC_FILES = {
+  "/": { contentType: "text/html; charset=utf-8", path: "index.html" },
+  "/index.html": { contentType: "text/html; charset=utf-8", path: "index.html" },
+  "/app.css": { contentType: "text/css; charset=utf-8", path: "app.css" },
+  "/app.js": { contentType: "text/javascript; charset=utf-8", path: "app.js" },
+  "/threadnote-logo.svg": { contentType: "image/svg+xml; charset=utf-8", path: "threadnote-logo.svg", root: "docs" }
+};
+async function runManage(config, options) {
+  const token = (0, import_node_crypto2.randomBytes)(24).toString("base64url");
+  const server = createManagerServer({ config, jobs: /* @__PURE__ */ new Map(), token });
+  const port = parseUiPort(options.uiPort);
+  await listen(server, port);
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const url = `http://127.0.0.1:${actualPort}/?token=${encodeURIComponent(token)}`;
+  console.log(`Threadnote manager: ${url}`);
+  console.log("Press Ctrl-C to stop the manager.");
+  if (options.open !== false) {
+    await runCommand("open", [url], { allowFailure: true });
+  }
+  await new Promise((resolve2, reject) => {
+    const close = () => server.close((err) => err ? reject(err) : resolve2());
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+  });
+}
+function createManagerServer(context) {
+  return (0, import_node_http2.createServer)((request, response) => {
+    void handleRequest(context, request, response).catch((err) => {
+      writeJson(response, 500, { error: errorMessage(err) });
+    });
+  });
+}
+async function memoryTree(config) {
+  const root = localMemoriesRoot(config);
+  return readTree(config, root, `viking://user/${uriSegment(config.user)}/memories`, "");
+}
+async function readManagedMemory(config, uri) {
+  assertVikingUri(uri);
+  const path = localPathForMemoryUri(config, uri);
+  if (!path) {
+    throw new Error(`Manager can only read current-user memory URIs: ${uri}`);
+  }
+  const [content, pathStat] = await Promise.all([(0, import_promises13.readFile)(path, "utf8"), (0, import_promises13.stat)(path)]);
+  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path).split(import_node_path13.sep).join("/");
+  const record = parseMemoryDocument(uri, content);
+  return {
+    content,
+    node: {
+      isDir: false,
+      isShared: isInSharedNamespace(config, uri),
+      isSystem: isSystemMemoryName(path.split(import_node_path13.sep).at(-1) ?? ""),
+      metadata: record?.metadata,
+      modTime: pathStat.mtime.toISOString(),
+      name: path.split(import_node_path13.sep).at(-1) ?? uri,
+      relativePath,
+      sharedTeam: sharedTeamNameForUri(config, uri),
+      size: pathStat.size,
+      uri
+    },
+    record
+  };
+}
+async function readContextUri(config, uri) {
+  assertVikingUri(uri);
+  try {
+    const localMemory = await readManagedMemory(config, uri);
+    return { content: localMemory.content, localMemory, output: localMemory.content };
+  } catch {
+    const result = await runCaptured(() => runRead(config, uri, {}));
+    return { content: result.output, output: result.output };
+  }
+}
+async function detectConsolidationAgents() {
+  const [codex, claude, cursor, copilot] = await Promise.all([
+    findExecutable(["codex"]),
+    findExecutable(["claude"]),
+    findExecutable(["cursor-agent"]),
+    findExecutable(["copilot"])
+  ]);
+  return [
+    { available: codex !== void 0, command: codex, id: "codex", label: "Codex" },
+    { available: claude !== void 0, command: claude, id: "claude", label: "Claude" },
+    { available: cursor !== void 0, command: cursor, id: "cursor", label: "Cursor" },
+    { available: copilot !== void 0, command: copilot, id: "copilot", label: "Copilot" }
+  ];
+}
+async function handleRequest(context, request, response) {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (request.method === "GET" && STATIC_FILES[url.pathname]) {
+    await serveStatic(context, url, response);
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/favicon.ico") {
+    response.writeHead(204, { "cache-control": "no-store" });
+    response.end();
+    return;
+  }
+  if (!isAuthorized(context, request)) {
+    writeJson(response, 401, { error: "Unauthorized" });
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/state") {
+    const agents = await detectConsolidationAgents();
+    const version = await currentPackageVersion();
+    let latestVersion;
+    try {
+      latestVersion = await fetchLatestVersion2(normalizeRegistry(updateRegistry()));
+    } catch {
+      latestVersion = void 0;
+    }
+    writeJson(response, 200, {
+      agents,
+      config: publicConfig(context.config),
+      latestVersion,
+      openVikingLogPath: openVikingLogPath(context.config),
+      version
+    });
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/tree") {
+    writeJson(response, 200, { tree: await memoryTree(context.config) });
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/memory") {
+    writeJson(response, 200, await readManagedMemory(context.config, requiredQuery(url, "uri")));
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/read") {
+    writeJson(response, 200, await readContextUri(context.config, requiredQuery(url, "uri")));
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/shares") {
+    writeJson(response, 200, { shares: await shareSummaries(context.config) });
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/doctor") {
+    writeJson(response, 200, {
+      checks: await collectManagerDoctorChecks(context.config),
+      shares: await shareSummaries(context.config)
+    });
+    return;
+  }
+  if (request.method === "GET" && url.pathname.startsWith("/api/consolidations/")) {
+    const id = url.pathname.split("/").at(-1) ?? "";
+    const job = context.jobs.get(id);
+    writeJson(response, job ? 200 : 404, job ? { job } : { error: "Consolidation job not found" });
+    return;
+  }
+  if (request.method !== "POST") {
+    writeJson(response, 404, { error: "Not found" });
+    return;
+  }
+  const body = await readJsonBody(request);
+  switch (url.pathname) {
+    case "/api/memory/archive":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(() => runArchive(context.config, requireString(body.uri, "uri"), body))
+      );
+      return;
+    case "/api/memory/forget":
+      requireConfirm(body);
+      writeJson(response, 200, await runCaptured(() => runForget(context.config, requireString(body.uri, "uri"), {})));
+      return;
+    case "/api/memory/save":
+      writeJson(response, 200, await saveMemory(context.config, body));
+      return;
+    case "/api/memory/move":
+      requireConfirm(body);
+      writeJson(response, 200, await moveMemory(context.config, requireString(body.uri, "uri"), targetFromBody(body)));
+      return;
+    case "/api/memory/publish":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runSharePublish(context.config, requireString(body.uri, "uri"), {
+            redact: body.redact === true,
+            team: optionalString(body.team)
+          })
+        )
+      );
+      return;
+    case "/api/memory/unpublish":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runShareUnpublish(context.config, requireString(body.uri, "uri"), { team: optionalString(body.team) })
+        )
+      );
+      return;
+    case "/api/folder/remove":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(() => removeManagedFolder(context.config, requireString(body.uri, "uri")))
+      );
+      return;
+    case "/api/bulk":
+      requireConfirm(body);
+      writeJson(response, 200, await runBulk(context.config, body));
+      return;
+    case "/api/compact":
+      if (body.apply === true) {
+        requireConfirm(body);
+      }
+      writeJson(response, 200, await runCaptured(() => runCompact(context.config, body)));
+      return;
+    case "/api/recall":
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runRecall(context.config, {
+            query: requireString(body.query, "query"),
+            nodeLimit: optionalString(body.nodeLimit)
+          })
+        )
+      );
+      return;
+    case "/api/read":
+      writeJson(response, 200, await readContextUri(context.config, requireString(body.uri, "uri")));
+      return;
+    case "/api/shares/init":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runShareInit(context.config, requireString(body.remoteUrl, "remoteUrl"), { team: optionalString(body.team) })
+        )
+      );
+      return;
+    case "/api/shares/rename":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runShareRename(context.config, { team: requireString(body.team, "team"), to: requireString(body.to, "to") })
+        )
+      );
+      return;
+    case "/api/shares/set-url":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runShareSetUrl(context.config, requireString(body.remoteUrl, "remoteUrl"), { team: optionalString(body.team) })
+        )
+      );
+      return;
+    case "/api/shares/remove":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runShareRemove(context.config, {
+            keepFiles: body.keepFiles === true,
+            preserveLocal: body.preserveLocal === true,
+            team: optionalString(body.team)
+          })
+        )
+      );
+      return;
+    case "/api/shares/sync":
+      writeJson(
+        response,
+        200,
+        await runCaptured(() => runShareSync(context.config, { team: optionalString(body.team) }))
+      );
+      return;
+    case "/api/doctor/start":
+      writeJson(response, 200, await runCaptured(() => runStart(context.config, {})));
+      return;
+    case "/api/doctor/repair-dry-run":
+      writeJson(response, 200, await runCaptured(() => runRepair(context.config, { dryRun: true })));
+      return;
+    case "/api/doctor/repair":
+      requireConfirm(body);
+      writeJson(response, 200, await runCaptured(() => runRepair(context.config, { dryRun: false })));
+      return;
+    case "/api/import-pack":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(() => runImportPack(context.config, { path: requireString(body.path, "path") }))
+      );
+      return;
+    case "/api/export-pack":
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => runExportPack(context.config, { path: optionalString(body.path), uri: optionalString(body.uri) })
+        )
+      );
+      return;
+    case "/api/seed":
+      requireConfirm(body);
+      writeJson(
+        response,
+        200,
+        await runCaptured(
+          () => body.skills === true ? runSeedSkills(context.config, { dryRun: body.dryRun === true }) : runSeed(context.config, { dryRun: body.dryRun === true })
+        )
+      );
+      return;
+    case "/api/consolidations":
+      writeJson(response, 200, { job: await createConsolidation(context, body) });
+      return;
+    default:
+      if (url.pathname.startsWith("/api/consolidations/") && url.pathname.endsWith("/apply")) {
+        requireConfirm(body);
+        const id = url.pathname.split("/").at(-2) ?? "";
+        writeJson(response, 200, await applyConsolidation(context.config, context.jobs, id, body));
+        return;
+      }
+      writeJson(response, 404, { error: "Not found" });
+  }
+}
+async function serveStatic(context, url, response) {
+  const file = STATIC_FILES[url.pathname] ?? STATIC_FILES["/"];
+  const content = await (0, import_promises13.readFile)((0, import_node_path13.join)(toolRoot(), file.root ?? "manager", file.path));
+  const headers = { "content-type": file.contentType };
+  if (url.pathname === "/" || url.pathname === "/index.html") {
+    headers["cache-control"] = "no-store";
+  }
+  response.writeHead(200, headers);
+  response.end(content);
+}
+async function readTree(config, path, uri, relativePath) {
+  const pathStat = await (0, import_promises13.stat)(path);
+  const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : "memories";
+  const isDir = pathStat.isDirectory();
+  if (!isDir) {
+    const content = await (0, import_promises13.readFile)(path, "utf8").catch(() => "");
+    const record = parseMemoryDocument(uri, content);
+    return {
+      isDir: false,
+      isShared: isInSharedNamespace(config, uri),
+      isSystem: isSystemMemoryName(name),
+      metadata: record?.metadata,
+      modTime: pathStat.mtime.toISOString(),
+      name,
+      relativePath,
+      sharedTeam: sharedTeamNameForUri(config, uri),
+      size: pathStat.size,
+      uri
+    };
+  }
+  const entries = await (0, import_promises13.readdir)(path, { withFileTypes: true });
+  const children = await Promise.all(
+    entries.sort(
+      (left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name)
+    ).map((entry) => {
+      const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+      return readTree(config, (0, import_node_path13.join)(path, entry.name), `${uri}/${entry.name}`, childRelative);
+    })
+  );
+  return {
+    children,
+    isDir: true,
+    isShared: isInSharedNamespace(config, uri),
+    isSystem: isSystemMemoryName(name),
+    modTime: pathStat.mtime.toISOString(),
+    name,
+    relativePath,
+    sharedTeam: sharedTeamNameForUri(config, uri),
+    size: pathStat.size,
+    uri
+  };
+}
+async function saveMemory(config, body) {
+  const text = requireString(body.text, "text");
+  const replaceUri = optionalString(body.replaceUri);
+  if (replaceUri && isRawMemoryDocument(text)) {
+    return runCaptured(() => writeRawMemory(config, replaceUri, text));
+  }
+  return runCaptured(
+    () => runRemember(config, {
+      kind: memoryKind(body.kind) ?? "durable",
+      project: optionalString(body.project),
+      replace: replaceUri,
+      sourceAgentClient: optionalString(body.sourceAgentClient) ?? "manager",
+      status: memoryStatus(body.status) ?? "active",
+      text,
+      topic: optionalString(body.topic)
+    })
+  );
+}
+async function writeRawMemory(config, uri, content) {
+  assertVikingUri(uri);
+  const ov = await openVikingCliForMode(false);
+  if (isInSharedNamespace(config, uri)) {
+    const teamName = sharedTeamNameForUri(config, uri);
+    if (!teamName) {
+      throw new Error(`${uri} is not in a configured shared namespace.`);
+    }
+    const team = await resolveTeam(config, teamName);
+    await ensureSharedDirectoryChain(config, ov, uri, false);
+    await writeMemoryFile(config, ov, uri, content, "replace", false);
+    const relativePath = vikingUriToWorktreeRelative(config, uri, team.name);
+    await publishShareGitChange(team.config.worktree, relativePath, `share: update ${relativePath}`);
+    return;
+  }
+  await ensurePersonalDirectoryChain2(config, ov, parentUri(uri));
+  await writeMemoryFile(config, ov, uri, content, "replace", false);
+}
+async function moveMemory(config, sourceUri, target) {
+  assertVikingUri(sourceUri);
+  const source = await readManagedMemory(config, sourceUri);
+  const sourceRecord = source.record;
+  const text = sourceRecord?.body ?? source.content;
+  const metadata = {
+    kind: target.kind ?? sourceRecord?.metadata.kind ?? "durable",
+    project: target.project ?? sourceRecord?.metadata.project ?? "general",
+    sourceAgentClient: target.sourceAgentClient ?? "manager",
+    status: target.status ?? sourceRecord?.metadata.status ?? "active",
+    topic: target.topic ?? sourceRecord?.metadata.topic ?? "current"
+  };
+  const personalTargetUri = memoryUriFor2(config, metadata);
+  if (target.team) {
+    const targetTeam = target.team;
+    if (isInSharedNamespace(config, sourceUri)) {
+      const team = sharedTeamNameForUri(config, sourceUri);
+      if (team !== targetTeam) {
+        throw new Error(
+          "Cross-team shared moves are not supported in V1. Copy/unpublish, then publish to the target team."
+        );
+      }
+      const sharedTargetUri = sharedMemoryUriFor(config, targetTeam, metadata);
+      const output3 = await runCaptured(
+        () => moveSharedWithinTeam(config, sourceUri, sharedTargetUri, source.content, targetTeam)
+      );
+      return { ...output3, targetUri: sharedTargetUri };
+    }
+    const saved = await runCaptured(
+      () => runRemember(config, {
+        kind: metadata.kind,
+        project: metadata.project,
+        replace: sourceUri,
+        sourceAgentClient: metadata.sourceAgentClient,
+        status: metadata.status,
+        text,
+        topic: metadata.topic
+      })
+    );
+    const published = await runCaptured(() => runSharePublish(config, personalTargetUri, { team: targetTeam }));
+    return {
+      output: [saved.output, published.output].filter(Boolean).join("\n"),
+      targetUri: sharedMemoryUriFor(config, targetTeam, metadata)
+    };
+  }
+  if (isInSharedNamespace(config, sourceUri)) {
+    const saved = await runCaptured(
+      () => runRemember(config, {
+        kind: metadata.kind,
+        project: metadata.project,
+        sourceAgentClient: metadata.sourceAgentClient,
+        status: metadata.status,
+        text,
+        topic: metadata.topic
+      })
+    );
+    const removed = await runCaptured(() => removeSharedSource(config, sourceUri));
+    return { output: [saved.output, removed.output].filter(Boolean).join("\n"), targetUri: personalTargetUri };
+  }
+  const output2 = await runCaptured(
+    () => runRemember(config, {
+      kind: metadata.kind,
+      project: metadata.project,
+      replace: sourceUri,
+      sourceAgentClient: metadata.sourceAgentClient,
+      status: metadata.status,
+      text,
+      topic: metadata.topic
+    })
+  );
+  return { ...output2, targetUri: personalTargetUri };
+}
+async function moveSharedWithinTeam(config, sourceUri, targetUri, content, teamName) {
+  const team = await resolveTeam(config, teamName);
+  const ov = await openVikingCliForMode(false);
+  await ensureSharedDirectoryChain(config, ov, targetUri, false);
+  await writeMemoryFile(config, ov, targetUri, content, "create", false);
+  await publishShareGitChange(
+    team.config.worktree,
+    vikingUriToWorktreeRelative(config, targetUri, team.name),
+    `share: move ${vikingUriToWorktreeRelative(config, sourceUri, team.name)} to ${vikingUriToWorktreeRelative(config, targetUri, team.name)}`
+  );
+  await publishShareGitChange(
+    team.config.worktree,
+    vikingUriToWorktreeRelative(config, sourceUri, team.name),
+    `share: remove ${vikingUriToWorktreeRelative(config, sourceUri, team.name)}`,
+    {
+      verb: "rm"
+    }
+  );
+  await removeMemoryUri(config, ov, sourceUri, false);
+}
+async function removeSharedSource(config, sourceUri) {
+  const teamName = sharedTeamNameForUri(config, sourceUri);
+  if (!teamName) {
+    throw new Error(`${sourceUri} is not a shared memory.`);
+  }
+  const team = await resolveTeam(config, teamName);
+  const ov = await openVikingCliForMode(false);
+  await publishShareGitChange(
+    team.config.worktree,
+    vikingUriToWorktreeRelative(config, sourceUri, team.name),
+    `share: remove ${vikingUriToWorktreeRelative(config, sourceUri, team.name)}`,
+    {
+      verb: "rm"
+    }
+  );
+  await removeMemoryUri(config, ov, sourceUri, false);
+}
+async function removeManagedFolder(config, uri) {
+  assertVikingUri(uri);
+  const rootUri = `viking://user/${uriSegment(config.user)}/memories`;
+  if (uri === rootUri) {
+    throw new Error("Refusing to remove the root memories folder.");
+  }
+  if (isInSharedNamespace(config, uri)) {
+    throw new Error("Shared folders are managed from Sharing. Remove the share or unpublish selected memories.");
+  }
+  const path = localPathForMemoryUri(config, uri);
+  if (!path) {
+    throw new Error(`Manager can only remove current-user memory folders: ${uri}`);
+  }
+  const pathStat = await (0, import_promises13.stat)(path);
+  if (!pathStat.isDirectory()) {
+    throw new Error(`Not a folder: ${uri}`);
+  }
+  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path13.sep).includes("..")) {
+    throw new Error("Refusing to remove a folder outside the memories tree.");
+  }
+  const fileUris = await fileUrisUnderFolder(config, path);
+  for (const fileUri of fileUris) {
+    await runForget(config, fileUri, {});
+  }
+  await (0, import_promises13.rm)(path, { force: true, recursive: true });
+  console.log(`Removed folder: ${uri}`);
+  console.log(`Forgot ${fileUris.length} file${fileUris.length === 1 ? "" : "s"}.`);
+}
+async function fileUrisUnderFolder(config, folderPath) {
+  const entries = await (0, import_promises13.readdir)(folderPath, { withFileTypes: true });
+  const uris = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const path = (0, import_node_path13.join)(folderPath, entry.name);
+    if (entry.isDirectory()) {
+      uris.push(...await fileUrisUnderFolder(config, path));
+    } else if (entry.isFile()) {
+      uris.push(localPathToMemoryUri(config, path));
+    }
+  }
+  return uris;
+}
+async function runBulk(config, body) {
+  const action = requireString(body.action, "action");
+  const uris = requireStringArray(body.uris, "uris");
+  const results = [];
+  for (const uri of uris) {
+    try {
+      let output2;
+      if (action === "archive") {
+        output2 = (await runCaptured(() => runArchive(config, uri, {}))).output;
+      } else if (action === "forget") {
+        output2 = (await runCaptured(() => runForget(config, uri, {}))).output;
+      } else if (action === "publish") {
+        output2 = (await runCaptured(() => runSharePublish(config, uri, { team: optionalString(body.team) }))).output;
+      } else {
+        throw new Error(`Unsupported bulk action: ${action}`);
+      }
+      results.push({ ok: true, output: output2, uri });
+    } catch (err) {
+      results.push({ error: errorMessage(err), ok: false, uri });
+    }
+  }
+  return { results };
+}
+async function createConsolidation(context, body) {
+  const agent = agentClient(requireString(body.agent, "agent"));
+  const sourceUris = requireStringArray(body.uris, "uris");
+  const target = targetFromBody(body);
+  const job = {
+    agent,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    id: (0, import_node_crypto2.randomUUID)(),
+    sourceUris,
+    status: "running",
+    target
+  };
+  context.jobs.set(job.id, job);
+  try {
+    const sources = await Promise.all(sourceUris.map((uri) => readManagedMemory(context.config, uri)));
+    job.draft = await runConsolidationAgent(agent, sources);
+    job.status = "completed";
+  } catch (err) {
+    job.error = errorMessage(err);
+    job.status = "failed";
+  }
+  return job;
+}
+async function applyConsolidation(config, jobs, id, body) {
+  const job = jobs.get(id);
+  if (!job) {
+    throw new Error("Consolidation job not found.");
+  }
+  if (job.status !== "completed" || !job.draft) {
+    throw new Error("Consolidation job is not completed.");
+  }
+  const draft = optionalString(body.draft) ?? job.draft;
+  const target = targetFromBody({ ...job.target, ...body });
+  const saved = await runCaptured(
+    () => runRemember(config, {
+      kind: target.kind ?? "durable",
+      project: target.project,
+      sourceAgentClient: target.sourceAgentClient ?? "manager",
+      status: target.status ?? "active",
+      text: draft,
+      topic: target.topic
+    })
+  );
+  const cleanup = cleanupMode(body.cleanup);
+  const cleanupOutputs = [];
+  if (cleanup !== "keep") {
+    for (const uri of job.sourceUris) {
+      if (isInSharedNamespace(config, uri) && body.cleanupShared !== true) {
+        cleanupOutputs.push(`Skipped shared source cleanup: ${uri}`);
+        continue;
+      }
+      const action = cleanup === "forget" ? () => runForget(config, uri, {}) : () => runArchive(config, uri, {});
+      cleanupOutputs.push((await runCaptured(action)).output);
+    }
+  }
+  return { output: [saved.output, ...cleanupOutputs].filter(Boolean).join("\n") };
+}
+async function runConsolidationAgent(agent, sources) {
+  if (agent !== "codex" && agent !== "claude") {
+    throw new Error(`${agent} does not expose a supported non-interactive consolidation mode.`);
+  }
+  const executable = await findExecutable([agent]);
+  if (!executable) {
+    throw new Error(`${agent} executable was not found.`);
+  }
+  const prompt = consolidationPrompt(sources);
+  const stagingDir = await (0, import_promises13.mkdtemp)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
+  const promptPath = (0, import_node_path13.join)(stagingDir, "prompt.txt");
+  try {
+    await (0, import_promises13.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
+    await (0, import_promises13.chmod)(promptPath, 384);
+    const script = consolidationAgentScript(agent, executable);
+    const result = await runCommand("sh", ["-lc", script, "threadnote-consolidate", promptPath], {
+      allowFailure: true,
+      maxOutputBytes: 1024 * 1024,
+      timeoutMs: 10 * 60 * 1e3
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || `${agent} exited with ${result.exitCode}`);
+    }
+    const draft = result.stdout.trim();
+    if (!draft) {
+      throw new Error(`${agent} returned an empty consolidation draft.`);
+    }
+    return draft;
+  } finally {
+    await (0, import_promises13.rm)(stagingDir, { force: true, recursive: true });
+  }
+}
+function consolidationAgentScript(agent, executable) {
+  if (agent === "codex") {
+    return `${shellQuote(executable)} exec --sandbox read-only --skip-git-repo-check - < "$1"`;
+  }
+  if (agent === "claude") {
+    return `${shellQuote(executable)} --print --permission-mode default < "$1"`;
+  }
+  throw new Error(`${agent} does not expose a supported non-interactive consolidation mode.`);
+}
+function consolidationPrompt(sources) {
+  return [
+    "Consolidate these Threadnote memories into one concise memory.",
+    "Return only the replacement memory body in Markdown. Do not include frontmatter.",
+    "Preserve important facts, current status, decisions, blockers, and source viking:// URIs.",
+    "",
+    ...sources.flatMap((source) => [`--- SOURCE ${source.node.uri} ---`, source.content.trim(), ""])
+  ].join("\n");
+}
+async function shareSummaries(config) {
+  const teamsFile = await readTeamsFile(config);
+  const git = await findExecutable(["git"]);
+  const entries = await Promise.all(
+    Object.values(teamsFile.teams).map(async (team) => {
+      if (!git) {
+        return { ...team, default: teamsFile.defaultTeam === team.name, warning: "git not found" };
+      }
+      const status = await runCommand(git, ["-C", team.worktree, "status", "--short", "--branch"], {
+        allowFailure: true
+      });
+      const ahead = await gitCount(git, team.worktree, "@{u}..HEAD");
+      const behind = await gitCount(git, team.worktree, "HEAD..@{u}");
+      return {
+        ...team,
+        ahead,
+        behind,
+        default: teamsFile.defaultTeam === team.name,
+        dirty: status.stdout.split("\n").some((line) => line.trim().length > 0 && !line.startsWith("##")),
+        status: status.stdout.trim(),
+        warning: status.exitCode === 0 ? void 0 : status.stderr.trim() || status.stdout.trim()
+      };
+    })
+  );
+  return entries.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function collectManagerDoctorChecks(config) {
+  const threadnote = await findExecutable(["threadnote"]);
+  if (!threadnote) {
+    return collectDoctorChecks(config, {});
+  }
+  const result = await runCommand(
+    threadnote,
+    [
+      "--home",
+      config.agentContextHome,
+      "--manifest",
+      config.manifestPath,
+      "--host",
+      config.host,
+      "--port",
+      String(config.port),
+      "doctor"
+    ],
+    { allowFailure: true, maxOutputBytes: 1024 * 1024 }
+  );
+  const checks = parseDoctorChecksFromOutput([result.stdout, result.stderr].filter(Boolean).join("\n"));
+  return checks.length > 0 ? checks : collectDoctorChecks(config, {});
+}
+function parseDoctorChecksFromOutput(output2) {
+  const ansiEscape = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+  return output2.split(/\r?\n/).map((line) => line.replace(ansiEscape, "").trim()).map((line) => /^(OK|WARN|FAIL)\s+([^:]+):\s*(.*)$/.exec(line)).filter((match) => match !== null).map((match) => ({
+    detail: match[3] ?? "",
+    name: match[2] ?? "",
+    status: doctorStatus(match[1] ?? "")
+  }));
+}
+async function gitCount(git, worktree, range) {
+  const result = await runCommand(git, ["-C", worktree, "rev-list", "--count", range], { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  return Number.parseInt(result.stdout.trim(), 10) || 0;
+}
+function doctorStatus(value) {
+  if (value === "OK") {
+    return "ok";
+  }
+  if (value === "FAIL") {
+    return "fail";
+  }
+  return "warn";
+}
+async function runCaptured(action) {
+  const lines = [];
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  console.log = (...args) => lines.push(args.map(String).join(" "));
+  console.warn = (...args) => lines.push(args.map(String).join(" "));
+  console.error = (...args) => lines.push(args.map(String).join(" "));
+  try {
+    await action();
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+  return { output: lines.join("\n") };
+}
+function memoryUriFor2(config, metadata) {
+  const project = uriSegment(metadata.project);
+  const filename = metadata.status === "active" && metadata.kind !== "smoke" ? `${uriSegment(metadata.topic)}.md` : `threadnote-${safeTimestamp()}-${sha256(JSON.stringify(metadata)).slice(0, 12)}.md`;
+  return `${memoryDirectoryUri2(config, metadata.kind, metadata.status, project)}/${filename}`;
+}
+function sharedMemoryUriFor(config, team, metadata) {
+  if (metadata.kind !== "durable") {
+    throw new Error("Only durable memories can be moved into shared team memory.");
+  }
+  return `viking://user/${uriSegment(config.user)}/memories/shared/${uriSegment(team)}/durable/projects/${uriSegment(metadata.project)}/${uriSegment(metadata.topic)}.md`;
+}
+function memoryDirectoryUri2(config, kind, status, projectSegment) {
+  const base = `viking://user/${uriSegment(config.user)}/memories`;
+  switch (kind) {
+    case "preference":
+      return status === "active" ? `${base}/preferences` : `${base}/preferences/${uriSegment(status)}`;
+    case "handoff":
+      return `${base}/handoffs/${uriSegment(status)}/${projectSegment}`;
+    case "incident":
+      return `${base}/incidents/${uriSegment(status)}/${projectSegment}`;
+    case "smoke":
+      return `${base}/smoke/${uriSegment(status)}`;
+    case "durable":
+      return status === "active" ? `${base}/durable/projects/${projectSegment}` : `${base}/durable/${uriSegment(status)}/${projectSegment}`;
+  }
+}
+function localMemoriesRoot(config) {
+  return (0, import_node_path13.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
+}
+function localPathForMemoryUri(config, uri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories`;
+  if (uri !== prefix && !uri.startsWith(`${prefix}/`)) {
+    return void 0;
+  }
+  const relativePath = uri === prefix ? "" : uri.slice(prefix.length + 1);
+  const segments = relativePath.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    return void 0;
+  }
+  return (0, import_node_path13.join)(localMemoriesRoot(config), ...segments);
+}
+function localPathToMemoryUri(config, path) {
+  const relativePath = (0, import_node_path13.relative)(localMemoriesRoot(config), path);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path13.sep).includes("..")) {
+    throw new Error(`Path is outside the memories tree: ${path}`);
+  }
+  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path13.sep).join("/")}`;
+}
+async function ensurePersonalDirectoryChain2(config, ov, directoryUri) {
+  const prefix = "viking://";
+  const parts = directoryUri.startsWith(prefix) ? directoryUri.slice(prefix.length).split("/").filter(Boolean) : [];
+  const startIndex = parts[0] === "user" && parts.length > 2 ? 3 : 1;
+  for (let index = startIndex; index <= parts.length; index += 1) {
+    const uri = `${prefix}${parts.slice(0, index).join("/")}`;
+    const statResult = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+    if (statResult.exitCode !== 0) {
+      await runCommand(
+        ov,
+        withIdentity(config, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
+      );
+    }
+  }
+}
+function publicConfig(config) {
+  return {
+    account: config.account,
+    agentContextHome: config.agentContextHome,
+    agentId: config.agentId,
+    host: config.host,
+    manifestPath: config.manifestPath,
+    port: config.port,
+    user: config.user
+  };
+}
+function parseUiPort(value) {
+  if (!value) {
+    return 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(`Invalid --ui-port "${value}".`);
+  }
+  return parsed;
+}
+function isAuthorized(context, request) {
+  const auth = request.headers.authorization;
+  return auth === `Bearer ${context.token}` || request.headers["x-threadnote-token"] === context.token;
+}
+function isSystemMemoryName(name) {
+  return name === ".abstract.md" || name === ".overview.md" || name === ".git" || name === ".gitignore";
+}
+async function listen(server, port) {
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve2();
+    });
+  });
+}
+async function readJsonBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object body.");
+  }
+  return parsed;
+}
+function writeJson(response, statusCode, body) {
+  response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  response.end(`${JSON.stringify(body)}
+`);
+}
+function requiredQuery(url, name) {
+  const value = url.searchParams.get(name);
+  if (!value) {
+    throw new Error(`Missing query parameter: ${name}`);
+  }
+  return value;
+}
+function requireString(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Provide ${name}.`);
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function requireStringArray(value, name) {
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string")) {
+    throw new Error(`Provide ${name} as a non-empty string array.`);
+  }
+  return value;
+}
+function requireConfirm(body) {
+  if (body.confirm !== true) {
+    throw new Error("Set confirm=true for this action.");
+  }
+}
+function targetFromBody(body) {
+  return {
+    kind: memoryKind(body.kind),
+    project: optionalString(body.project),
+    sourceAgentClient: optionalString(body.sourceAgentClient),
+    status: memoryStatus(body.status),
+    team: optionalString(body.team),
+    topic: optionalString(body.topic)
+  };
+}
+function memoryKind(value) {
+  return value === "durable" || value === "handoff" || value === "incident" || value === "preference" || value === "smoke" ? value : void 0;
+}
+function memoryStatus(value) {
+  return value === "active" || value === "archived" || value === "superseded" ? value : void 0;
+}
+function isRawMemoryDocument(text) {
+  return text.startsWith("MEMORY\n") || text.startsWith("HANDOFF\n");
+}
+function agentClient(value) {
+  if (value === "codex" || value === "claude" || value === "cursor" || value === "copilot") {
+    return value;
+  }
+  throw new Error(`Unsupported consolidation agent: ${value}`);
+}
+function cleanupMode(value) {
+  if (value === "forget" || value === "keep") {
+    return value;
+  }
+  return "archive";
+}
+
 // src/threadnote.ts
 async function main() {
   const program2 = new Command();
   program2.name("threadnote").description("Threadnote shared context workflow for development agents").showHelpAfterError().option("--home <path>", "Override THREADNOTE_HOME for this invocation").option("--manifest <path>", "Override THREADNOTE_MANIFEST for this invocation").option("--host <host>", "OpenViking host", DEFAULT_HOST).option("--port <port>", "OpenViking port", parsePort, DEFAULT_PORT);
+  program2.command("manage").description("Open the local Threadnote web manager").option("--ui-port <port>", "Port for the local manager UI; defaults to a random free port").option("--no-open", "Start the manager without opening a browser").action(async (options) => {
+    await runManage(getRuntimeConfig(program2), options);
+  });
   program2.command("doctor").description("Check local prerequisites, config files, manifest shape, and server health").option("--dry-run", "Show checks without writing anything").option("--strict", "Exit non-zero if any check fails").action(async (options) => {
     const config = getRuntimeConfig(program2);
     await runDoctor(config, options);
@@ -12390,6 +13802,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);
   });
@@ -12515,7 +13930,13 @@ async function main() {
   share.command("list").description("List configured shared teams").option("--dry-run", "Print without side effects (no-op for list)").action(async (options) => {
     await runShareList(getRuntimeConfig(program2), options);
   });
-  share.command("remove").description("Forget a configured team and optionally delete its worktree/gitdir").option("--team <name>", "Team name; defaults to the configured default team").option("--keep-files", "Keep the worktree and gitdir on disk; only forget the team entry").option("--dry-run", "Print actions without running them").action(async (options) => {
+  share.command("rename").description("Rename a configured shared team").requiredOption("--team <name>", "Existing team name").requiredOption("--to <name>", "New team name").option("--dry-run", "Print actions without running them").action(async (options) => {
+    await runShareRename(getRuntimeConfig(program2), options);
+  });
+  share.command("set-url").description("Change the git remote URL for a configured shared team").argument("<remote-url>", "New git remote URL").option("--team <name>", "Team name; defaults to the configured default team").option("--dry-run", "Print actions without running them").action(async (remoteUrl, options) => {
+    await runShareSetUrl(getRuntimeConfig(program2), remoteUrl, options);
+  });
+  share.command("remove").description("Forget a configured team and optionally delete its worktree/gitdir").option("--team <name>", "Team name; defaults to the configured default team").option("--keep-files", "Keep the worktree and gitdir on disk; only forget the team entry").option("--preserve-local", "Copy shared durable memories into the personal tree before removing the team").option("--dry-run", "Print actions without running them").action(async (options) => {
     await runShareRemove(getRuntimeConfig(program2), options);
   });
   program2.command("export-pack").description("Export local OpenViking context to an .ovpack").option("--dry-run", "Print ov command without exporting").option("--path <path>", "Output .ovpack path").option("--uri <uri>", "Source viking:// URI to export", "viking://").action(async (options) => {