threadnote 0.7.8 → 0.7.10

package/dist/threadnote.cjs

@@ -3756,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) {
@@ -8234,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) {
@@ -8282,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);
@@ -8328,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}`);
 }
@@ -8365,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}`);
 }
@@ -8393,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)) {
@@ -8419,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) {
@@ -8816,47 +9093,6 @@ 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) {
@@ -9311,6 +9547,40 @@ async function runCompact(config, options) {
     await runForget(config, action.uri, { dryRun: false });
   }
 }
+async function runCompactDiagnostics(config, options) {
+  const project = normalizeOptionalMetadata2(options.project);
+  if (!project) {
+    throw new Error("Provide --project for scoped memory hygiene.");
+  }
+  const topic = normalizeOptionalMetadata2(options.topic);
+  const records = await scopedCompactRecords(config, {
+    kind: options.kind,
+    project
+  });
+  const activeRecords = records.filter((record) => record.metadata.status === "active");
+  const matchingRecords = activeRecords.filter((record) => topic === void 0 || topicForRecord(record) === topic);
+  const counts = /* @__PURE__ */ new Map();
+  for (const record of matchingRecords) {
+    const kind = record.metadata.kind;
+    if (kind === "durable" || kind === "handoff" || kind === "incident") {
+      counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    }
+  }
+  console.log(
+    [
+      "Scope summary:",
+      `- project: ${project}`,
+      `- topic: ${topic ?? "(all)"}`,
+      `- kind: ${options.kind ?? "(handoff, durable, incident)"}`,
+      `- stable records read: ${records.length}`,
+      `- active records in project: ${activeRecords.length}`,
+      `- active records matching topic: ${matchingRecords.length}`,
+      `- matching by kind: ${formatKindCounts(counts)}`,
+      "- skipped by design: archived memories, shared memories, preferences, smoke records, seeded resources, and non-stable timestamped/global paths",
+      ""
+    ].join("\n")
+  );
+}
 async function scopedCompactRecords(config, options) {
   const kinds = options.kind ? [options.kind] : ["handoff", "durable", "incident"];
   const records = [];
@@ -9339,6 +9609,9 @@ async function scopedCompactRecords(config, options) {
   }
   return records;
 }
+function formatKindCounts(counts) {
+  return ["handoff", "durable", "incident"].map((kind) => `${kind} ${counts.get(kind) ?? 0}`).join(", ");
+}
 async function readMemoryRecordsByUri(config, uris) {
   const records = [];
   for (const uri of uris) {
@@ -9386,11 +9659,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);
@@ -9624,62 +9897,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]);
@@ -9706,8 +9937,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));
@@ -11514,6 +11745,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)() });
@@ -11533,16 +11777,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;
@@ -12601,20 +12836,1010 @@ function printWhatsNew(whatsNew) {
   }
 }
 
-// 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("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);
-    await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
+// 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" },
+  "/threadnote-logo-inverted.svg": {
+    contentType: "image/svg+xml; charset=utf-8",
+    path: "threadnote-logo-inverted.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);
   });
-  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--force", "Reinstall OpenViking at the pinned version even if a working install is already present").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
-    "--with-hooks",
-    "Also install agent-side hooks (Claude PreCompact + SessionStart) for deterministic handoff snapshots and context preload"
-  ).action(async (options) => {
-    const config = getRuntimeConfig(program2);
+}
+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(async () => {
+          await runCompactDiagnostics(context.config, body);
+          await 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);
+    await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
+  });
+  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--force", "Reinstall OpenViking at the pinned version even if a working install is already present").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
+    "--with-hooks",
+    "Also install agent-side hooks (Claude PreCompact + SessionStart) for deterministic handoff snapshots and context preload"
+  ).action(async (options) => {
+    const config = getRuntimeConfig(program2);
     await runInstall(config, options);
     if (options.withHooks === true) {
       const dryRun = options.dryRun === true;
@@ -12754,7 +13979,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) => {