threadnote 0.6.3 → 0.7.1

package/dist/threadnote.cjs

@@ -3523,8 +3523,8 @@ var DEFAULT_SEED_PATTERNS = [
 ];
 
 // src/hooks.ts
-var import_promises6 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
 
 // src/mcp.ts
 var import_node_fs2 = require("node:fs");
@@ -4487,8 +4487,8 @@ function existsSyncDirectory(path) {
 }
 
 // src/memory.ts
-var import_promises4 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
+var import_promises5 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
 
 // src/manifest.ts
 var import_promises3 = require("node:fs/promises");
@@ -7230,2460 +7230,2711 @@ function renderTemplate(template, config) {
   return template.replaceAll("{{THREADNOTE_HOME}}", config.agentContextHome).replaceAll("{{OPENVIKING_ACCOUNT}}", config.account).replaceAll("{{OPENVIKING_AGENT_ID}}", config.agentId).replaceAll("{{OPENVIKING_HOST}}", config.host).replaceAll("{{OPENVIKING_PORT}}", String(config.port)).replaceAll("{{OPENVIKING_USER}}", config.user);
 }
 
-// src/memory.ts
-function parseMemoryKind(value) {
-  if (["durable", "handoff", "incident", "preference", "smoke"].includes(value)) {
-    return value;
+// src/share.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_os4 = require("node:os");
+var import_node_path4 = require("node:path");
+var TEAMS_FILE_VERSION = 1;
+var SHARED_SEGMENT = "shared";
+var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
+var AUTO_SHARE_FETCH_INTERVAL_MS = 5 * 60 * 1e3;
+var DEFAULT_GIT_REMOTE_NAME = "origin";
+var SCRUBBER_PATTERNS = [
+  // Credentials: never redactable. Blocking is the only safe response —
+  // automated redaction risks false negatives that leave material in git.
+  { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { name: "API key (sk-...)", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
+  { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
+  { name: "GitHub fine-grained PAT", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}/ },
+  { name: "GitLab PAT", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
+  { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
+  // Matches bare JWTs (three base64url segments). May surface a JWE token in
+  // legitimate docs; if that becomes noisy we can switch to warn-only.
+  { name: "JWT", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
+  { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ },
+  // Slack tokens: xoxa/xoxb/xoxc (configuration)/xoxd (legacy user cookie)/
+  // xoxe (refresh)/xoxp/xoxr/xoxs, with optional -N- segment for the workspace tier.
+  { name: "Slack token", regex: /\bxox[abcdeprs](?:-\d-)?[A-Za-z0-9._-]{10,}/i },
+  // Soft leaks: block by default (so the agent sees them and decides), but
+  // allow opt-in redaction so curated memories with incidental matches can
+  // ship without a manual rewrite. Local home paths are the recurring
+  // real-world leak; the regexes greedily consume the whole path segment
+  // (including subdirectories) up to whitespace or common closing punctuation
+  // so redaction collapses an entire path to a single placeholder rather than
+  // leaving the subpath visible.
+  { name: "macOS home path", placeholder: "<local-path>", regex: /\/Users\/[^\s)>"'`,]+/ },
+  { name: "linux home path", placeholder: "<local-path>", regex: /\b\/home\/[^\s)>"'`,]+/ }
+];
+function applyScrubber(content, { redact }) {
+  let cleaned = content;
+  const redactions = [];
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (!pattern.regex.test(cleaned)) {
+      continue;
+    }
+    if (!pattern.placeholder || !redact) {
+      return { blocker: pattern.name, cleaned: content, redactions: [] };
+    }
+    const flags = pattern.regex.flags.includes("g") ? pattern.regex.flags : `${pattern.regex.flags}g`;
+    const globalRegex = new RegExp(pattern.regex.source, flags);
+    const matches = cleaned.match(globalRegex) ?? [];
+    cleaned = cleaned.replace(globalRegex, pattern.placeholder);
+    redactions.push({ count: matches.length, name: pattern.name });
   }
-  throw new Error(`Unsupported memory kind "${value}". Expected durable, handoff, incident, preference, or smoke.`);
+  return { cleaned, redactions };
 }
-function parseMemoryStatus(value) {
-  if (["active", "archived", "superseded"].includes(value)) {
-    return value;
+var autoShareStates = /* @__PURE__ */ new Map();
+async function runShareInit(config, remoteUrl, options) {
+  if (!remoteUrl.trim()) {
+    throw new Error("Provide a git remote URL for the shared memories repo.");
   }
-  throw new Error(`Unsupported memory status "${value}". Expected active, archived, or superseded.`);
-}
-async function runRemember(config, options) {
-  const text = await getInputText(options.text, options.stdin === true);
-  if (!text.trim()) {
-    throw new Error("Provide memory text with --text or --stdin.");
+  const dryRun = options.dryRun === true;
+  const teamName = normalizeTeamName(options.team);
+  const teamsFile = await readTeamsFile(config);
+  if (teamsFile.teams[teamName]) {
+    throw new Error(
+      `Team "${teamName}" is already configured (remote ${teamsFile.teams[teamName].remote}). Remove it first with: threadnote share remove --team ${teamName}`
+    );
   }
-  const metadata = {
-    kind: options.kind ?? "durable",
-    project: normalizeOptionalMetadata(options.project),
-    sourceAgentClient: options.sourceAgentClient ?? "codex",
-    status: options.status ?? "active",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    topic: normalizeOptionalMetadata(options.topic)
+  const worktree = teamWorktreePath(config, teamName);
+  const gitdir = teamGitdirPath(config, teamName);
+  await assertWorktreeUsable(worktree);
+  if (await exists(gitdir)) {
+    throw new Error(`Gitdir already exists at ${gitdir}; remove it or pick a different team name.`);
+  }
+  await ensureDirectory((0, import_node_path4.dirname)(worktree), dryRun);
+  await ensureDirectory((0, import_node_path4.dirname)(gitdir), dryRun);
+  const git = await requiredExecutable("git");
+  await maybeRun(dryRun, git, ["clone", `--separate-git-dir=${gitdir}`, "--", remoteUrl, worktree]);
+  const newConfig = {
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gitdir,
+    name: teamName,
+    remote: remoteUrl,
+    worktree
   };
-  await storeMemory(config, {
-    bodyText: text.trim(),
-    dryRun: options.dryRun === true,
-    metadata,
-    replaceUri: options.replace,
-    title: "MEMORY"
-  });
+  const updatedTeams = {
+    defaultTeam: shouldSetDefault(options, teamsFile) ? teamName : teamsFile.defaultTeam ?? teamName,
+    teams: { ...teamsFile.teams, [teamName]: newConfig },
+    version: TEAMS_FILE_VERSION
+  };
+  if (dryRun) {
+    console.log(`Would write teams file: ${teamsFilePath(config)}`);
+    console.log(`Would set ${teamName} as default? ${updatedTeams.defaultTeam === teamName}`);
+  } else {
+    await writeTeamsFile(config, updatedTeams);
+    console.log(`Configured shared team "${teamName}" -> ${portablePath(worktree)}`);
+  }
+  if (!dryRun) {
+    await ensureSharedGitignore(worktree, git, options.push !== false);
+    const ingested = await ingestWorktreeFiles(config, newConfig, "create");
+    console.log(`Ingested ${ingested} shared memory file(s) into OpenViking.`);
+  }
 }
-async function runMigrateMemories(config, options) {
-  const dryRun = options.dryRun === true;
-  const limit = options.limit ? parsePositiveInteger(options.limit, "migration limit") : void 0;
-  const sourceAccounts = await legacySourceAccounts(config, options);
-  if (sourceAccounts.length === 0) {
-    console.log("No local OpenViking accounts found to scan.");
+var SHARED_GITIGNORE_PATTERNS = ["**/.abstract.md", "**/.overview.md"];
+var SHARED_GITIGNORE_HEADER = "# Threadnote: ignore OpenViking-generated directory summaries.";
+async function ensureSharedGitignore(worktree, git, push) {
+  const gitignorePath = (0, import_node_path4.join)(worktree, ".gitignore");
+  const existing = await readFileIfExists(gitignorePath) ?? "";
+  const lines = existing.split("\n").map((line) => line.trim());
+  const missingPatterns = SHARED_GITIGNORE_PATTERNS.filter((pattern) => !lines.includes(pattern));
+  if (missingPatterns.length === 0) {
     return;
   }
-  const candidates = await legacyMemoryCandidates(config, sourceAccounts);
-  const existingHashes = await existingDurableMemoryHashes(config);
-  const ov = await openVikingCliForMode(dryRun);
-  const migrationPath = (0, import_node_path4.join)(config.agentContextHome, "legacy-memory-migration.txt");
-  let duplicateCount = 0;
-  let migratedCount = 0;
-  let sensitiveCount = 0;
-  if (!dryRun && candidates.length > 0) {
-    await ensureDurableMemoryDirectory(ov, config);
+  const hasHeader = lines.includes(SHARED_GITIGNORE_HEADER);
+  const segments = [];
+  if (existing.length > 0 && !existing.endsWith("\n")) {
+    segments.push("\n");
   }
-  try {
-    for (const candidate of candidates) {
-      if (existingHashes.has(candidate.hash)) {
-        duplicateCount += 1;
-        continue;
-      }
-      if (existingHashes.has(candidate.comparableHash)) {
-        duplicateCount += 1;
-        continue;
-      }
-      const sensitiveReason = sensitiveMemoryReason(candidate.text);
-      if (sensitiveReason) {
-        sensitiveCount += 1;
-        console.log(
-          `SKIP ${legacySourceLabel(candidate)}: possible ${sensitiveReason}; inspect the source archive manually if needed.`
+  if (existing.length > 0) {
+    segments.push("\n");
+  }
+  if (!hasHeader) {
+    segments.push(SHARED_GITIGNORE_HEADER, "\n");
+  }
+  segments.push(missingPatterns.join("\n"), "\n");
+  await (0, import_promises4.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
+  console.log(`Added ${missingPatterns.join(", ")} to ${portablePath(gitignorePath)}`);
+  await maybeRun(false, git, ["-C", worktree, "add", ".gitignore"]);
+  const commitResult = await runCommand(
+    git,
+    ["-C", worktree, "commit", "-m", "share: ignore OpenViking directory summaries"],
+    { allowFailure: true }
+  );
+  if (commitResult.exitCode !== 0) {
+    const detail = commitResult.stderr.trim() || commitResult.stdout.trim();
+    if (!/nothing to commit|no changes added/i.test(detail)) {
+      console.warn(
+        `.gitignore housekeeping commit was rejected (${detail || "unknown"}); it will be retried on the next share sync.`
+      );
+      return;
+    }
+  }
+  if (push) {
+    await maybeRun(false, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+  }
+}
+async function runShareStatus(config, options) {
+  const team = await resolveTeam(config, options.team);
+  const git = await requiredExecutable("git");
+  console.log(`Team: ${team.name}`);
+  console.log(`Remote: ${team.config.remote}`);
+  console.log(`Worktree: ${portablePath(team.config.worktree)}`);
+  console.log(`Gitdir: ${portablePath(team.config.gitdir)}`);
+  await maybeRun(options.dryRun === true, git, ["-C", team.config.worktree, "status", "--short", "--branch"]);
+  await maybeRun(options.dryRun === true, git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME], {
+    allowFailure: true
+  });
+  const ahead = await gitOutput(team.config.worktree, ["rev-list", "--count", "@{u}..HEAD"], options.dryRun === true);
+  const behind = await gitOutput(team.config.worktree, ["rev-list", "--count", "HEAD..@{u}"], options.dryRun === true);
+  if (ahead !== void 0) {
+    console.log(`Ahead of upstream: ${ahead}`);
+  }
+  if (behind !== void 0) {
+    console.log(`Behind upstream: ${behind}`);
+  }
+}
+async function syncSharedReposBeforeAgentRead(config) {
+  const state = autoShareState(config);
+  return enqueueShareOperation(state, async () => {
+    await loadPendingReindexes(config, state);
+    const warnings = await refreshShareUpdateStateLocked(config, state, { force: false });
+    const syncTeams = /* @__PURE__ */ new Set([...state.behindTeams, ...state.pendingReindexes.keys()]);
+    if (syncTeams.size === 0) {
+      return { syncedTeams: [], warnings };
+    }
+    const syncedTeams = [];
+    const remainingBehind = new Set(state.behindTeams);
+    for (const team of syncTeams) {
+      try {
+        const warning = await runShareSyncQuiet(config, state, { team });
+        if (warning) {
+          warnings.push(warning);
+        } else {
+          remainingBehind.delete(team);
+          syncedTeams.push(team);
+        }
+      } catch (err) {
+        warnings.push(
+          `Auto-sync for shared team "${team}" failed: ${err instanceof Error ? err.message : String(err)}`
         );
-        continue;
-      }
-      if (limit !== void 0 && migratedCount >= limit) {
-        break;
       }
-      const memoryUri = migratedDurableMemoryUri(config, candidate.hash);
-      if (!dryRun && await vikingResourceExists(ov, config, memoryUri)) {
-        duplicateCount += 1;
-        existingHashes.add(candidate.hash);
+    }
+    state.behindTeams = remainingBehind;
+    state.lastCheckedAt = Date.now();
+    return { syncedTeams, warnings };
+  });
+}
+function autoShareState(config) {
+  const key = `${config.agentContextHome}:${config.account}:${config.user}`;
+  let state = autoShareStates.get(key);
+  if (!state) {
+    state = { behindTeams: /* @__PURE__ */ new Set(), lastCheckedAt: 0, pendingReindexes: /* @__PURE__ */ new Map() };
+    autoShareStates.set(key, state);
+  }
+  return state;
+}
+function pendingReindexesPath(config) {
+  return (0, import_node_path4.join)(config.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+}
+async function loadPendingReindexes(config, state) {
+  const raw = await readFileIfExists(pendingReindexesPath(config));
+  if (!raw) {
+    state.pendingReindexes = /* @__PURE__ */ new Map();
+    return;
+  }
+  const parsed = parseJsonConfigObject(raw);
+  if (!parsed || typeof parsed.teams !== "object" || parsed.teams === null || Array.isArray(parsed.teams)) {
+    state.pendingReindexes = /* @__PURE__ */ new Map();
+    return;
+  }
+  const pending = /* @__PURE__ */ new Map();
+  for (const [team, value] of Object.entries(parsed.teams)) {
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    const changes = [];
+    for (const item of value) {
+      if (typeof item !== "object" || item === null || Array.isArray(item)) {
         continue;
       }
-      console.log(`${dryRun ? "Would migrate" : "Migrating"} ${legacySourceLabel(candidate)} -> ${memoryUri}`);
-      if (!dryRun) {
-        await (0, import_promises4.writeFile)(migrationPath, candidate.text, { encoding: "utf8", mode: 384 });
-        await (0, import_promises4.chmod)(migrationPath, 384);
-        await writeDurableMemoryFile(ov, config, memoryUri, migrationPath, "create");
-        existingHashes.add(candidate.hash);
+      const entry = item;
+      if (typeof entry.path === "string" && typeof entry.relativePath === "string" && (entry.status === "added" || entry.status === "removed" || entry.status === "modified")) {
+        changes.push({ path: entry.path, relativePath: entry.relativePath, status: entry.status });
       }
-      migratedCount += 1;
     }
-  } finally {
-    if (!dryRun) {
-      await (0, import_promises4.rm)(migrationPath, { force: true });
+    if (changes.length > 0) {
+      pending.set(team, changes);
     }
   }
-  console.log(
-    [
-      `Migration summary: ${migratedCount} ${dryRun ? "would be migrated" : "migrated"}`,
-      `${duplicateCount} duplicate(s) skipped`,
-      `${sensitiveCount} sensitive-looking item(s) skipped`,
-      `${candidates.length} legacy Threadnote item(s) scanned`,
-      `source account(s): ${sourceAccounts.join(", ")}`
-    ].join("; ")
-  );
+  state.pendingReindexes = pending;
 }
-async function runMigrateLifecycle(config, options) {
-  const dryRun = options.dryRun === true || options.apply !== true;
-  const limit = options.limit ? parsePositiveInteger(options.limit, "lifecycle migration limit") : void 0;
-  const ov = await openVikingCliForMode(dryRun);
-  const candidates = await legacyLifecycleHandoffCandidates(config);
-  const migrationPath = (0, import_node_path4.join)(config.agentContextHome, "lifecycle-memory-migration.txt");
-  let existingCount = 0;
-  let migratedCount = 0;
-  let skippedCount = 0;
+async function writePendingReindexes(config, state) {
+  const path = pendingReindexesPath(config);
+  if (state.pendingReindexes.size === 0) {
+    await (0, import_promises4.rm)(path, { force: true });
+    return;
+  }
+  const contents = {
+    teams: Object.fromEntries(state.pendingReindexes),
+    version: 1
+  };
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.tmp`;
+  await (0, import_promises4.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await (0, import_promises4.rename)(tempPath, path);
+}
+async function refreshShareUpdateStateLocked(config, state, options) {
+  const now = Date.now();
+  if (!options.force && state.lastCheckedAt > 0 && now - state.lastCheckedAt < AUTO_SHARE_FETCH_INTERVAL_MS) {
+    return [];
+  }
   try {
-    for (const candidate of candidates) {
-      if (limit !== void 0 && migratedCount >= limit) {
-        break;
+    const statuses = await fetchShareUpdateStatuses(config);
+    const nextBehindTeams = new Set(state.behindTeams);
+    for (const status of statuses) {
+      if (status.warning) {
+        continue;
       }
-      const destinationUri = lifecycleMigrationUri(config, candidate.metadata, sha256(candidate.original.trim()));
-      const migratedMemory = formatMemoryDocument(
-        "HANDOFF",
-        candidate.metadata,
-        ["Migrated legacy handoff from the historical events trail.", "", candidate.original.trim()].join("\n")
-      );
-      console.log(`${dryRun ? "Would migrate" : "Migrating"} ${candidate.sourceUri} -> ${destinationUri}`);
-      if (!dryRun) {
-        if (await vikingResourceExists(ov, config, destinationUri)) {
-          existingCount += 1;
-          console.log(`Archived copy already exists; cleaning up legacy source: ${candidate.sourceUri}`);
-        } else {
-          await (0, import_promises4.writeFile)(migrationPath, migratedMemory, { encoding: "utf8", mode: 384 });
-          await (0, import_promises4.chmod)(migrationPath, 384);
-          await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, candidate.metadata));
-          await writeDurableMemoryFile(ov, config, destinationUri, migrationPath, "create");
-        }
-        const removedOriginal = await removeVikingResourceWithRetry(ov, config, candidate.sourceUri);
-        if (!removedOriginal) {
-          console.error(
-            `Migrated copy stored, but original is still processing. Retry later: threadnote forget ${candidate.sourceUri}`
-          );
-          skippedCount += 1;
-        }
+      if (status.behind > 0) {
+        nextBehindTeams.add(status.team);
+      } else {
+        nextBehindTeams.delete(status.team);
       }
-      migratedCount += 1;
     }
+    state.behindTeams = nextBehindTeams;
+    return statuses.flatMap((status) => status.warning ? [status.warning] : []);
   } finally {
-    if (!dryRun) {
-      await (0, import_promises4.rm)(migrationPath, { force: true });
-    }
+    state.lastCheckedAt = Date.now();
   }
-  console.log(
-    [
-      `Lifecycle migration summary: ${migratedCount} clear legacy handoff(s) ${dryRun ? "would be migrated" : "migrated"}`,
-      `${existingCount} existing archived copy/copies reused`,
-      `${skippedCount} legacy source(s) still processing`,
-      `${candidates.length} clear legacy handoff candidate(s) found`,
-      dryRun ? "Run with --apply to perform this migration." : void 0
-    ].filter((part) => part !== void 0).join("; ")
-  );
 }
-async function runRecall(config, options) {
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, options.query));
-  const args = ["search", options.query];
-  if (inferredUri) {
-    args.push("--uri", inferredUri);
-    console.log(`Recall scope: ${inferredUri}`);
-  }
-  if (options.nodeLimit) {
-    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
-  }
-  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
-  await augmentRecallWithSeededResources(config, ov, options, inferredUri);
-  await printExactMemoryMatches(config, ov, options.query, {
-    dryRun: options.dryRun === true,
-    includeArchived: options.includeArchived === true
-  });
+function enqueueShareOperation(state, action) {
+  const previous = state.operationPromise ?? Promise.resolve();
+  const current = previous.catch(() => void 0).then(action);
+  state.operationPromise = current.catch(() => void 0);
+  return current;
 }
-async function augmentRecallWithSeededResources(config, ov, options, inferredUri) {
-  if (options.uri || options.inferScope === false) {
-    return;
-  }
-  const project = await inferProjectFromQuery(config.manifestPath, options.query);
-  if (!project) {
-    return;
-  }
-  const projectResourceUri = trimTrailingSlash(project.uri);
-  if (!projectResourceUri.startsWith("viking://") || projectResourceUri === inferredUri) {
-    return;
+async function fetchShareUpdateStatuses(config) {
+  const teamsFile = await readTeamsFile(config);
+  const teams = Object.entries(teamsFile.teams);
+  if (teams.length === 0) {
+    return [];
   }
-  const args = ["search", options.query, "--uri", projectResourceUri];
-  if (options.nodeLimit) {
-    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  const git = await requiredExecutable("git");
+  const statuses = [];
+  for (const [name, team] of teams) {
+    const fetchResult = await runCommand(git, ["-C", team.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME], {
+      allowFailure: true
+    });
+    if (fetchResult.exitCode !== 0) {
+      statuses.push({
+        behind: 0,
+        team: name,
+        warning: `Auto-sync check for shared team "${name}" failed: ${fetchResult.stderr.trim() || fetchResult.stdout.trim() || "unknown git fetch error"}`
+      });
+      continue;
+    }
+    const behind = await gitOutput(team.worktree, ["rev-list", "--count", "HEAD..@{u}"], false);
+    if (behind === void 0) {
+      statuses.push({
+        behind: 0,
+        team: name,
+        warning: `Auto-sync check for shared team "${name}" failed: could not read upstream behind count.`
+      });
+      continue;
+    }
+    statuses.push({ behind: Number.parseInt(behind, 10) || 0, team: name });
   }
-  console.log(`
-Also searching seeded resources: ${projectResourceUri}`);
-  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  return statuses;
 }
-async function runRead(config, uri, options) {
-  assertVikingUri(uri);
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const result = await maybeRun(options.dryRun === true, ov, withIdentity(config, ["read", uri]));
-  if (result && result.stdout.includes("[Directory overview is not ready]") && (uri.endsWith("/.overview.md") || uri.endsWith("/.abstract.md"))) {
-    const parentUri2 = parentVikingUri(uri);
-    console.log("\nThis is a generated summary placeholder. To read the underlying content, inspect leaf nodes:");
-    console.log(`  threadnote list ${parentUri2} --all --recursive`);
+async function runShareSync(config, options) {
+  const team = await resolveTeam(config, options.team);
+  const dryRun = options.dryRun === true;
+  const git = await requiredExecutable("git");
+  const worktree = team.config.worktree;
+  if (!dryRun) {
+    await ensureSharedGitignore(worktree, git, false);
   }
-}
-async function runList(config, uri, options) {
-  assertVikingUri(uri);
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const args = ["ls", uri];
-  if (options.all === true) {
-    args.push("--all");
+  if (await hasUncommittedChanges(worktree)) {
+    if (options.autoCommit === false) {
+      throw new Error(
+        `Worktree ${worktree} has uncommitted changes. Commit them yourself or rerun without --no-auto-commit.`
+      );
+    }
+    const message = options.message ?? `share: sync ${(/* @__PURE__ */ new Date()).toISOString()}`;
+    await stageShareableChanges(dryRun, git, worktree);
+    await maybeRun(dryRun, git, ["-C", worktree, "commit", "-m", message], { allowFailure: true });
   }
-  if (options.recursive === true) {
-    args.push("--recursive");
+  const beforeRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
+  await maybeRun(dryRun, git, ["-C", worktree, "fetch", DEFAULT_GIT_REMOTE_NAME]);
+  const pullResult = dryRun ? void 0 : await runCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME])}`);
+  } else if (pullResult && pullResult.exitCode !== 0) {
+    if (await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-apply"))) {
+      throw new Error(
+        `git pull --rebase reported conflicts in ${worktree}. The worktree is in a rebase-in-progress state.
+Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then re-run \`threadnote share sync\`.`
+      );
+    }
+    throw new Error(
+      `git pull --rebase failed in ${worktree}: ${pullResult.stderr.trim() || pullResult.stdout.trim() || "unknown error"}`
+    );
   }
-  if (options.simple === true) {
-    args.push("--simple");
+  const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
+  if (!dryRun && beforeRev && afterRev && beforeRev !== afterRev) {
+    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
+    await applyChangesToOpenViking(config, team.config, changes);
+    console.log(`Reindexed ${changes.length} file change(s) into OpenViking.`);
+  } else if (!dryRun) {
+    console.log("No upstream changes to reindex.");
   }
-  if (options.nodeLimit) {
-    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  if (options.push !== false) {
+    await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
   }
-  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
-}
-async function runHandoff(config, options) {
-  const { bodyText, metadata } = await buildHandoff(options);
-  await storeMemory(config, {
-    bodyText,
-    dryRun: options.dryRun === true,
-    metadata,
-    replaceUri: options.replace,
-    title: "HANDOFF"
-  });
 }
-async function runArchive(config, uri, options) {
-  assertVikingUri(uri);
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const readResult = await maybeRun(options.dryRun === true, ov, withIdentity(config, ["read", uri]));
-  const original = readResult?.stdout.trim();
-  if (options.dryRun === true) {
-    const fallbackMetadata = {
-      archivedFrom: uri,
-      kind: options.kind ?? "handoff",
-      project: normalizeOptionalMetadata(options.project),
-      sourceAgentClient: "threadnote",
-      status: "archived",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      topic: normalizeOptionalMetadata(options.topic)
-    };
-    await storeMemory(config, {
-      bodyText: ["Archived original Threadnote memory.", "", "<original memory content would be read here>"].join("\n"),
-      dryRun: true,
-      metadata: fallbackMetadata,
-      title: "MEMORY"
-    });
-    console.log(formatShellCommand(ov, withIdentity(config, ["rm", uri])));
-    return;
+async function runShareSyncQuiet(config, state, options) {
+  const team = await resolveTeam(config, options.team);
+  const git = await requiredExecutable("git");
+  const worktree = team.config.worktree;
+  const pendingChanges = state.pendingReindexes.get(team.name);
+  if (pendingChanges) {
+    await applyChangesToOpenViking(config, team.config, pendingChanges, { quiet: true });
+    state.pendingReindexes.delete(team.name);
+    await writePendingReindexes(config, state);
   }
-  if (!original) {
-    throw new Error(`Could not read ${uri} before archiving.`);
+  if (await hasUncommittedChanges(worktree)) {
+    return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
   }
-  const inferredMetadata = inferMemoryMetadata(original);
-  const metadata = {
-    archivedFrom: uri,
-    kind: options.kind ?? inferredMetadata.kind ?? "handoff",
-    project: normalizeOptionalMetadata(options.project) ?? inferredMetadata.project,
-    sourceAgentClient: "threadnote",
-    status: "archived",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    topic: normalizeOptionalMetadata(options.topic) ?? inferredMetadata.topic
-  };
-  await storeMemory(config, {
-    bodyText: ["Archived original Threadnote memory.", "", original].join("\n"),
-    dryRun: false,
-    metadata,
-    title: "MEMORY"
-  });
-  const removedOriginal = await removeVikingResourceWithRetry(ov, config, uri);
-  if (removedOriginal) {
-    console.log(`Archived original memory: ${uri}`);
-  } else {
-    console.error(`Archive stored, but original memory is still processing. Retry later: threadnote forget ${uri}`);
+  const ahead = await gitOutput(worktree, ["rev-list", "--count", "@{u}..HEAD"], false);
+  if (ahead === void 0) {
+    return `Shared team "${team.name}" upstream status is unknown; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to inspect and resolve it.`;
   }
-}
-async function runForget(config, uri, options) {
-  assertVikingUri(uri);
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  if (options.dryRun === true) {
-    await maybeRun(true, ov, withIdentity(config, ["rm", uri]));
-    return;
+  if ((Number.parseInt(ahead, 10) || 0) > 0) {
+    return `Shared team "${team.name}" has local commits ahead of upstream; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or reconcile them.`;
   }
-  const removed = await removeVikingResourceWithRetry(ov, config, uri);
-  if (!removed) {
-    throw new Error(`Resource is still being processed; retry later: threadnote forget ${uri}`);
+  const beforeRev = await gitOutput(worktree, ["rev-parse", "HEAD"], false);
+  const pullResult = await runCommand(git, ["-C", worktree, "rebase", "@{u}"], { allowFailure: true });
+  if (pullResult.exitCode !== 0) {
+    if (await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-apply"))) {
+      throw new Error(
+        `Automatic share sync hit git conflicts in ${worktree}. Resolve them in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then rerun recall/read.`
+      );
+    }
+    throw new Error(
+      `Automatic share sync failed in ${worktree}: ${pullResult.stderr.trim() || pullResult.stdout.trim() || "unknown error"}`
+    );
   }
+  const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], false);
+  if (beforeRev && afterRev && beforeRev !== afterRev) {
+    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
+    if (changes.length > 0) {
+      state.pendingReindexes.set(team.name, changes);
+      await writePendingReindexes(config, state);
+      await applyChangesToOpenViking(config, team.config, changes, { quiet: true });
+      state.pendingReindexes.delete(team.name);
+      await writePendingReindexes(config, state);
+    }
+  }
+  return void 0;
 }
-async function runExportPack(config, options) {
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const defaultPath = (0, import_node_path4.join)(config.agentContextHome, `threadnote-${safeTimestamp()}.ovpack`);
-  const outputPath = expandPath(options.path ?? defaultPath);
-  await maybeRun(options.dryRun === true, ov, withIdentity(config, ["export", options.uri ?? "viking://", outputPath]));
+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 runImportPack(config, options) {
-  if (!options.path) {
-    throw new Error("Provide --path for import-pack.");
+async function runSharePublish(config, sourceUri, options) {
+  assertVikingUri(sourceUri);
+  const team = await resolveTeam(config, options.team);
+  const dryRun = options.dryRun === true;
+  const preview = options.preview === true;
+  if (isInSharedNamespace(config, sourceUri)) {
+    throw new Error(`Memory ${sourceUri} is already in the shared namespace.`);
   }
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  await maybeRun(
-    options.dryRun === true,
-    ov,
-    withIdentity(config, ["import", expandPath(options.path), options.targetUri ?? "viking://"])
-  );
-}
-async function inferRecallUri(config, query) {
-  if (!/\bskills?\b/.test(query.toLowerCase())) {
-    return void 0;
-  }
-  const project = await inferProjectFromQuery(config.manifestPath, query);
-  return project ? `viking://resources/agent-skills/repo-local-${uriSegment(project.name)}` : "viking://resources/agent-skills";
-}
-async function printExactMemoryMatches(config, ov, query, options) {
-  const terms = exactRecallTerms(query);
-  if (terms.length === 0) {
-    return;
-  }
-  const scopes = exactMemoryScopes(config, options.includeArchived);
-  const outputs = [];
-  for (const term of terms) {
-    for (const scope of scopes) {
-      const args = withIdentity(config, ["grep", term, "--uri", scope, "--node-limit", "5"]);
-      if (options.dryRun) {
-        outputs.push(formatShellCommand(ov, args));
-        continue;
-      }
-      const result = await runCommand(ov, args, { allowFailure: true });
-      const output2 = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-      if (result.exitCode === 0 && grepOutputHasMatches(output2)) {
-        outputs.push(output2);
-      }
+  const ov = await openVikingCliForMode(dryRun);
+  const rawContent = await readMemoryContent(config, ov, sourceUri, dryRun);
+  const stripped = stripPersonalProvenance(rawContent);
+  const scrub = applyScrubber(stripped, { redact: options.redact === true });
+  const targetUri = sharedUriFor(config, sourceUri, team.name);
+  if (preview) {
+    console.log(`PREVIEW source: ${sourceUri}`);
+    console.log(`PREVIEW destination: ${targetUri}`);
+    if (scrub.blocker) {
+      console.log(
+        `PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or rerun with --redact for soft-leak patterns.`
+      );
+      return;
     }
-  }
-  if (outputs.length === 0) {
+    for (const redaction of scrub.redactions) {
+      console.log(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
+    }
+    console.log("-----BEGIN PREVIEW-----");
+    console.log(scrub.cleaned);
+    console.log("-----END PREVIEW-----");
     return;
   }
-  console.log("\nExact durable memory matches:");
-  console.log(outputs.join("\n\n"));
-}
-async function storeMemory(config, options) {
-  if (options.replaceUri) {
-    assertVikingUri(options.replaceUri);
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to publish ${sourceUri}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
+    );
   }
-  const ov = await openVikingCliForMode(options.dryRun);
-  const memoryPath = (0, import_node_path4.join)(config.agentContextHome, "last-memory.txt");
-  const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
-  const candidateMemory = formatMemoryDocument(options.title, candidateMetadata, options.bodyText);
-  const memoryUri = memoryUriFor(config, candidateMemory, candidateMetadata);
-  const isInPlaceUpdate = options.replaceUri !== void 0 && options.replaceUri === memoryUri;
-  const finalMetadata = isInPlaceUpdate ? { ...options.metadata, supersedes: void 0 } : candidateMetadata;
-  const memory = isInPlaceUpdate ? formatMemoryDocument(options.title, finalMetadata, options.bodyText) : candidateMemory;
-  const writeMode = await memoryWriteMode(ov, config, memoryUri, finalMetadata);
-  if (options.dryRun) {
-    console.log(memory);
-    console.log("\nWould run:");
-    console.log(
-      formatShellCommand(
-        ov,
-        withIdentity(config, [
-          "write",
-          memoryUri,
-          "--from-file",
-          memoryPath,
-          "--mode",
-          writeMode,
-          "--wait",
-          "--timeout",
-          "120"
-        ])
-      )
+  for (const redaction of scrub.redactions) {
+    console.log(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
+  }
+  const content = scrub.cleaned;
+  if (!dryRun && await vikingResourceExists(ov, config, targetUri)) {
+    throw new Error(
+      `Refusing to publish: ${targetUri} already exists in the shared namespace. Inspect it via threadnote read; if it should be replaced, forget the existing shared copy first.`
     );
-    if (options.replaceUri && !isInPlaceUpdate) {
-      console.log(formatShellCommand(ov, withIdentity(config, ["rm", options.replaceUri])));
-    }
-    return;
   }
-  await (0, import_promises4.writeFile)(memoryPath, memory, { encoding: "utf8", mode: 384 });
-  await (0, import_promises4.chmod)(memoryPath, 384);
-  await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, finalMetadata));
-  await writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode);
-  console.log(`Stored memory: ${memoryUri}`);
-  if (options.replaceUri && !isInPlaceUpdate) {
-    const removedReplacedMemory = await removeVikingResourceWithRetry(ov, config, options.replaceUri);
-    if (removedReplacedMemory) {
-      console.log(`Forgot replaced memory: ${options.replaceUri}`);
-    } else {
-      console.error(
-        `Replacement stored, but the superseded memory is still processing. Retry later: threadnote forget ${options.replaceUri}`
+  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`
       );
     }
-  } else if (isInPlaceUpdate) {
-    console.log(`Updated existing memory in place: ${memoryUri}`);
   }
+  console.log(`Published ${sourceUri} -> ${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 vikingResourceExists(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 runShareUnpublish(config, sourceUri, options) {
+  assertVikingUri(sourceUri);
+  const team = await resolveTeam(config, options.team);
+  const dryRun = options.dryRun === true;
+  if (!isInTeamNamespace(config, sourceUri, team.name)) {
+    throw new Error(`Memory ${sourceUri} is not in team "${team.name}" shared namespace.`);
   }
-}
-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());
+  const ov = await openVikingCliForMode(dryRun);
+  const content = await readMemoryContent(config, ov, sourceUri, dryRun);
+  const targetUri = personalUriFor(config, sourceUri, team.name);
+  if (!dryRun && await vikingResourceExists(ov, config, targetUri)) {
+    throw new Error(
+      `Refusing to unpublish: a personal memory already exists at ${targetUri}. Move or forget it first, then retry.`
+    );
   }
-  if (result.stderr.trim()) {
-    console.error(result.stderr.trim());
+  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 });
   }
+  console.log(`Unpublished ${sourceUri} -> ${targetUri}`);
 }
-async function removeVikingResourceWithRetry(ov, config, uri) {
-  const args = withIdentity(config, ["rm", uri]);
-  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 true;
-    }
-    if (isResourceBusy(result.stderr, result.stdout) && attempt === 3) {
-      return false;
-    }
-    if (!isResourceBusy(result.stderr, result.stdout)) {
-      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
-    }
-    await sleep(1e3 * (attempt + 1));
+async function runShareList(config, _options) {
+  const teams = await readTeamsFile(config);
+  const entries = Object.values(teams.teams);
+  if (entries.length === 0) {
+    console.log("No shared teams configured. Run: threadnote share init <remote-url>");
+    return;
+  }
+  for (const team of entries) {
+    const marker = team.name === teams.defaultTeam ? " (default)" : "";
+    console.log(`- ${team.name}${marker}`);
+    console.log(`    remote: ${team.remote}`);
+    console.log(`    worktree: ${portablePath(team.worktree)}`);
+    console.log(`    gitdir: ${portablePath(team.gitdir)}`);
+    console.log(`    added: ${team.addedAt}`);
   }
-  return false;
-}
-async function vikingResourceExists(ov, config, uri) {
-  const stat4 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-  return stat4.exitCode === 0;
-}
-async function ensureDurableMemoryDirectory(ov, config) {
-  await ensureMemoryDirectory(ov, config, durableMemoryDirectoryUri(config));
 }
-async function ensureMemoryDirectory(ov, config, directoryUri) {
-  for (const uri of vikingDirectoryChain(directoryUri)) {
-    const statResult = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-    if (statResult.exitCode === 0) {
-      continue;
+async function runShareRemove(config, options) {
+  const team = await resolveTeam(config, options.team);
+  const dryRun = options.dryRun === true;
+  const teamsFile = await readTeamsFile(config);
+  const remaining = {};
+  for (const [name, value] of Object.entries(teamsFile.teams)) {
+    if (name !== team.name) {
+      remaining[name] = value;
     }
-    await maybeRun(
-      false,
-      ov,
-      withIdentity(config, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
-    );
+  }
+  const remainingNames = Object.keys(remaining);
+  const nextDefault = teamsFile.defaultTeam === team.name ? remainingNames[0] : teamsFile.defaultTeam;
+  const updated = { defaultTeam: nextDefault, teams: remaining, version: TEAMS_FILE_VERSION };
+  if (dryRun) {
+    console.log(`Would update teams file: ${teamsFilePath(config)}`);
+  } else {
+    await writeTeamsFile(config, updated);
+    console.log(`Removed team "${team.name}" from teams.json.`);
+  }
+  if (options.keepFiles !== true) {
+    await removePath(team.config.worktree, "shared worktree", dryRun);
+    await removePath(team.config.gitdir, "shared gitdir", dryRun);
+  } else {
+    console.log(`Keeping files at ${portablePath(team.config.worktree)} and ${portablePath(team.config.gitdir)}`);
   }
 }
-function durableMemoryDirectoryUri(config) {
-  return `viking://user/${uriSegment(config.user)}/memories/events`;
-}
-function migratedDurableMemoryUri(config, hash) {
-  return `${durableMemoryDirectoryUri(config)}/threadnote-migrated-${hash.slice(0, 16)}.md`;
-}
-async function hasLegacyLifecycleHandoffCandidates(config) {
-  return (await legacyLifecycleHandoffCandidates(config, 1)).length > 0;
-}
-async function legacyLifecycleHandoffCandidates(config, limit) {
-  const eventsRoot = (0, import_node_path4.join)(localUserMemoriesRoot(config), "events");
-  let entries;
-  try {
-    entries = await (0, import_promises4.readdir)(eventsRoot, { withFileTypes: true });
-  } catch (_err) {
-    return [];
+function normalizeTeamName(input2) {
+  const candidate = (input2 ?? "default").trim();
+  if (!candidate) {
+    return "default";
   }
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
-      continue;
-    }
-    const sourcePath = (0, import_node_path4.join)(eventsRoot, entry.name);
-    const original = await readTextIfExists(sourcePath);
-    if (!original || !isClearLegacyHandoffMemory(original) || sensitiveMemoryReason(original)) {
-      continue;
-    }
-    const sourceUri = `${durableMemoryDirectoryUri(config)}/${entry.name}`;
-    candidates.push({
-      metadata: {
-        archivedFrom: sourceUri,
-        kind: "handoff",
-        project: inferLegacyProject(original),
-        sourceAgentClient: "threadnote",
-        status: "archived",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      original,
-      sourceUri
-    });
-    if (limit !== void 0 && candidates.length >= limit) {
-      break;
-    }
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(candidate) || /^\.+$/.test(candidate)) {
+    throw new Error(
+      `Invalid team name "${input2}". Team names must start with a lowercase letter or digit and contain only [a-z0-9._-]. Single-dot or dot-only names are rejected so they don't collapse to the shared-root or parent directory.`
+    );
   }
-  return candidates;
+  return candidate;
 }
-function lifecycleMigrationUri(config, metadata, hash) {
-  return `${memoryDirectoryUri(config, metadata)}/legacy-${hash.slice(0, 16)}.md`;
+function teamsFilePath(config) {
+  return (0, import_node_path4.join)(config.agentContextHome, "share", "teams.json");
 }
-function exactMemoryScopes(config, includeArchived) {
-  const userBase = `viking://user/${uriSegment(config.user)}/memories`;
-  const scopes = [
-    `${userBase}/preferences`,
-    `${userBase}/durable/projects`,
-    `${userBase}/handoffs/active`,
-    `${userBase}/incidents/active`,
-    `${userBase}/events`,
-    `${userBase}/shared`,
-    `viking://agent/${uriSegment(config.agentId)}/memories`,
-    // Seeded project resources (READMEs, AGENTS.md, SKILL.md, docs/**) live
-    // under viking://resources/repos/<project>. Include them so an exact-term
-    // grep in a recall surfaces matches in seeded guidance, not only memories.
-    "viking://resources/repos"
-  ];
-  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+function teamWorktreePath(config, team) {
+  return (0, import_node_path4.join)(
+    config.agentContextHome,
+    "data",
+    "viking",
+    config.account,
+    "user",
+    uriSegment(config.user),
+    "memories",
+    SHARED_SEGMENT,
+    team
+  );
 }
-function memoryUriFor(config, memory, metadata) {
-  const filename = shouldUseStableMemoryUri(metadata) ? `${uriSegment(metadata.topic ?? "current")}.md` : `threadnote-${safeTimestamp()}-${sha256(memory).slice(0, 12)}.md`;
-  return `${memoryDirectoryUri(config, metadata)}/${filename}`;
+function teamGitdirPath(config, team) {
+  return (0, import_node_path4.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
-function memoryDirectoryUri(config, metadata) {
-  const baseUri = `viking://user/${uriSegment(config.user)}/memories`;
-  const projectSegment = uriSegment(metadata.project ?? "general");
-  switch (metadata.kind) {
-    case "preference":
-      return metadata.status === "active" ? `${baseUri}/preferences` : `${baseUri}/preferences/${uriSegment(metadata.status)}`;
-    case "handoff":
-      return `${baseUri}/handoffs/${uriSegment(metadata.status)}/${projectSegment}`;
-    case "incident":
-      return `${baseUri}/incidents/${uriSegment(metadata.status)}/${projectSegment}`;
-    case "smoke":
-      return `${baseUri}/smoke/${uriSegment(metadata.status)}`;
-    case "durable":
-      return metadata.status === "active" ? `${baseUri}/durable/projects/${projectSegment}` : `${baseUri}/durable/${uriSegment(metadata.status)}/${projectSegment}`;
+async function readTeamsFile(config) {
+  const path = teamsFilePath(config);
+  const raw = await readFileIfExists(path);
+  if (!raw) {
+    return { teams: {}, version: TEAMS_FILE_VERSION };
   }
-}
-function shouldUseStableMemoryUri(metadata) {
-  return metadata.status === "active" && metadata.topic !== void 0 && metadata.kind !== "smoke";
-}
-async function memoryWriteMode(ov, config, memoryUri, metadata) {
-  if (!shouldUseStableMemoryUri(metadata)) {
-    return "create";
+  const parsed = parseJsonConfigObject(raw);
+  if (!parsed) {
+    throw new Error(`Could not parse teams file ${path}`);
   }
-  return await vikingResourceExists(ov, config, memoryUri) ? "replace" : "create";
-}
-function vikingDirectoryChain(directoryUri) {
-  const prefix = "viking://";
-  if (!directoryUri.startsWith(prefix)) {
-    return [directoryUri];
+  if (typeof parsed.version === "number" && parsed.version > TEAMS_FILE_VERSION) {
+    throw new Error(
+      `Teams file ${path} was written with version ${parsed.version}; this Threadnote binary understands up to version ${TEAMS_FILE_VERSION}. Upgrade Threadnote (\`threadnote update\`) before continuing.`
+    );
   }
-  const parts = directoryUri.slice(prefix.length).split("/").filter(Boolean);
-  const startIndex = parts[0] === "user" && parts.length > 2 ? 3 : 1;
-  const chain = [];
-  for (let index = startIndex; index <= parts.length; index += 1) {
-    chain.push(`${prefix}${parts.slice(0, index).join("/")}`);
+  const teams = {};
+  if (typeof parsed.teams === "object" && parsed.teams !== null && !Array.isArray(parsed.teams)) {
+    for (const [name, value] of Object.entries(parsed.teams)) {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        console.warn(`Skipping non-object team entry "${name}" in ${path}.`);
+        continue;
+      }
+      const entry = value;
+      if (typeof entry.remote !== "string" || entry.remote.length === 0) {
+        console.warn(`Skipping team entry "${name}" in ${path}: missing or empty "remote" field.`);
+        continue;
+      }
+      teams[name] = {
+        addedAt: typeof entry.addedAt === "string" ? entry.addedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+        gitdir: typeof entry.gitdir === "string" ? entry.gitdir : teamGitdirPath(config, name),
+        name,
+        remote: entry.remote,
+        worktree: typeof entry.worktree === "string" ? entry.worktree : teamWorktreePath(config, name)
+      };
+    }
   }
-  return chain;
-}
-function formatMemoryDocument(title, metadata, body) {
-  const header = [
-    title,
-    `kind: ${metadata.kind}`,
-    `status: ${metadata.status}`,
-    metadata.project ? `project: ${metadata.project}` : void 0,
-    metadata.topic ? `topic: ${metadata.topic}` : void 0,
-    `source_agent_client: ${metadata.sourceAgentClient}`,
-    `timestamp: ${metadata.timestamp}`,
-    metadata.supersedes ? `supersedes: ${metadata.supersedes}` : void 0,
-    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0
-  ].filter((line) => line !== void 0);
-  return [...header, "", body.trim()].join("\n");
+  const defaultTeam = typeof parsed.defaultTeam === "string" ? parsed.defaultTeam : void 0;
+  return { defaultTeam, teams, version: TEAMS_FILE_VERSION };
 }
-function inferMemoryMetadata(memory) {
-  const header = memory.slice(0, Math.max(0, memory.indexOf("\n\n")) || memory.length);
-  const firstLine2 = header.split("\n")[0]?.trim();
-  const kind = parseOptionalMemoryKind(parseHeaderValue(header, "kind")) ?? (firstLine2 === "HANDOFF" ? "handoff" : void 0);
-  const status = parseOptionalMemoryStatus(parseHeaderValue(header, "status"));
-  const project = normalizeOptionalMetadata(parseHeaderValue(header, "project")) ?? normalizeOptionalMetadata(parseHeaderValue(header, "repo"));
-  const topic = normalizeOptionalMetadata(parseHeaderValue(header, "topic")) ?? normalizeOptionalMetadata(parseHeaderValue(header, "task"));
-  return {
-    kind,
-    project,
-    sourceAgentClient: parseHeaderValue(header, "source_agent_client") ?? void 0,
-    status,
-    topic
+async function writeTeamsFile(config, contents) {
+  const path = teamsFilePath(config);
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  const serializable = {
+    defaultTeam: contents.defaultTeam,
+    teams: contents.teams,
+    version: contents.version
   };
+  await (0, import_promises4.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
 }
-function parseHeaderValue(header, key) {
-  const prefix = `${key}:`;
-  return header.split("\n").find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
-}
-function isClearLegacyHandoffMemory(memory) {
-  if (/^kind:\s*/m.test(memory) || /^status:\s*/m.test(memory)) {
-    return false;
-  }
-  const trimmed = memory.trim();
-  if (trimmed.startsWith("HANDOFF\n")) {
-    return true;
+async function resolveTeam(config, requested) {
+  const teamsFile = await readTeamsFile(config);
+  const entries = Object.entries(teamsFile.teams);
+  if (entries.length === 0) {
+    throw new Error("No shared teams configured. Run: threadnote share init <remote-url>");
   }
-  if (!trimmed.startsWith("MEMORY\n")) {
-    return false;
+  const wantName = requested ? normalizeTeamName(requested) : teamsFile.defaultTeam ?? entries[0][0];
+  const found = teamsFile.teams[wantName];
+  if (!found) {
+    const known = entries.map(([name]) => name).join(", ");
+    throw new Error(`Team "${wantName}" is not configured. Known teams: ${known}`);
   }
-  return /^(?:#+\s*)?(?:final\s+)?handoff(?:\s+update)?\b/i.test(memoryBody(trimmed));
-}
-function memoryBody(memory) {
-  const separatorIndex = memory.indexOf("\n\n");
-  return separatorIndex === -1 ? "" : memory.slice(separatorIndex + 2).trim();
+  return { config: found, name: wantName };
 }
-function inferLegacyProject(memory) {
-  const explicit = parseHeaderValue(memory, "project") ?? parseHeaderValue(memory, "repo") ?? parseHeaderValue(memory, "repo_path") ?? /\brepo(?:_path)?\s+([~/A-Za-z0-9_.:/-]+)/.exec(memory)?.[1];
-  if (!explicit) {
-    return "general";
+function shouldSetDefault(options, existing) {
+  if (options.setDefault === true) {
+    return true;
   }
-  const trimmed = explicit.trim().replace(/[`.,;]+$/g, "");
-  return trimmed.includes("/") ? (0, import_node_path4.basename)(trimmed) : trimmed;
+  return existing.defaultTeam === void 0;
 }
-function parseOptionalMemoryKind(value) {
-  if (!value) {
-    return void 0;
+async function assertWorktreeUsable(worktree) {
+  if (!await exists(worktree)) {
+    return;
   }
-  try {
-    return parseMemoryKind(value);
-  } catch (_err) {
-    return void 0;
+  if (!await isDirectory(worktree)) {
+    throw new Error(`Cannot use ${worktree} as a worktree: not a directory.`);
   }
-}
-function parseOptionalMemoryStatus(value) {
-  if (!value) {
-    return void 0;
+  const entries = await (0, import_promises4.readdir)(worktree);
+  if (entries.length > 0) {
+    const preview = entries.slice(0, 5).join(", ");
+    const suffix = entries.length > 5 ? `, +${entries.length - 5} more` : "";
+    throw new Error(
+      `Worktree ${worktree} is not empty (contains: ${preview}${suffix}). Move or remove its contents, then retry threadnote share init.`
+    );
   }
-  try {
-    return parseMemoryStatus(value);
-  } catch (_err) {
-    return void 0;
-  }
-}
-function normalizeOptionalMetadata(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
 }
-async function legacySourceAccounts(config, options) {
-  const explicitAccounts = options.sourceAccount?.filter((account) => account.trim().length > 0) ?? [];
-  if (explicitAccounts.length > 0) {
-    return uniqueStrings(explicitAccounts);
-  }
-  if (options.allAccounts === true) {
-    const accounts = await childDirectoryNames(localVikingDataRoot(config));
-    return accounts.filter((account) => !account.startsWith("_"));
+async function ingestWorktreeFiles(config, team, initialMode) {
+  const ov = await openVikingCliForMode(false);
+  const files = await walkMemoryFiles(team.worktree);
+  for (const file of files) {
+    const uri = workfileToVikingUri(config, team, file);
+    await ensureSharedDirectoryChain(config, ov, uri, false);
+    await ingestSingleFile(ov, config, uri, file, initialMode);
   }
-  return [config.account];
+  return files.length;
 }
-async function legacyMemoryCandidates(config, sourceAccounts) {
-  const candidates = [];
-  for (const sourceAccount of sourceAccounts) {
-    const sessionRoot = (0, import_node_path4.join)(localVikingDataRoot(config), sourceAccount, "session");
-    for (const sourceSession of await childDirectoryNames(sessionRoot)) {
-      const historyRoot = (0, import_node_path4.join)(sessionRoot, sourceSession, "history");
-      for (const sourceArchive of await childDirectoryNames(historyRoot)) {
-        if (!sourceArchive.startsWith("archive_")) {
+async function walkMemoryFiles(root) {
+  const out = [];
+  async function visit(path, depth) {
+    let entries;
+    try {
+      entries = await (0, import_promises4.readdir)(path, { withFileTypes: true });
+    } catch (err) {
+      console.warn(`Skipping ${path} during shared-tree walk: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === ".git") {
+        continue;
+      }
+      const full = (0, import_node_path4.join)(path, entry.name);
+      if (entry.isDirectory()) {
+        if (depth === 0 && !SHAREABLE_MEMORY_KIND_DIRS.includes(entry.name)) {
           continue;
         }
-        const sourcePath = (0, import_node_path4.join)(historyRoot, sourceArchive, "messages.jsonl");
-        for (const text of await legacyMemoryTexts(sourcePath)) {
-          candidates.push({
-            comparableHash: sha256(comparableMemoryText(text)),
-            hash: sha256(text),
-            sourceAccount,
-            sourceArchive,
-            sourceSession,
-            text
-          });
-        }
+        await visit(full, depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (depth === 0) {
+        continue;
+      }
+      if (!entry.name.endsWith(".md")) {
+        continue;
       }
+      out.push(full);
     }
   }
-  return candidates.sort((left, right) => legacySourceLabel(left).localeCompare(legacySourceLabel(right)));
+  await visit(root, 0);
+  return out;
 }
-async function legacyMemoryTexts(sourcePath) {
-  const raw = await readTextIfExists(sourcePath);
-  if (!raw) {
-    return [];
+function workfileToVikingUri(config, team, filePath) {
+  const rel = (0, import_node_path4.relative)(team.worktree, filePath).split(import_node_path4.sep).join("/");
+  return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
+}
+function isInSharedNamespace(config, uri) {
+  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`);
+}
+function isInTeamNamespace(config, uri, team) {
+  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`);
+}
+function sharedUriFor(config, personalUri, team) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/`;
+  if (!personalUri.startsWith(prefix)) {
+    throw new Error(`Refusing to publish memory outside the current user namespace: ${personalUri}`);
   }
-  const memories = [];
-  for (const line of raw.split("\n")) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine) {
-      continue;
+  const rest = personalUri.slice(prefix.length);
+  return `${prefix}${SHARED_SEGMENT}/${team}/${rest}`;
+}
+function personalUriFor(config, sharedUri, team) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`;
+  if (!sharedUri.startsWith(prefix)) {
+    throw new Error(`Refusing to unpublish a URI outside team "${team}" shared namespace: ${sharedUri}`);
+  }
+  const rest = sharedUri.slice(prefix.length);
+  return `viking://user/${uriSegment(config.user)}/memories/${rest}`;
+}
+function vikingUriToWorktreeRelative(config, uri, team) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`;
+  if (!uri.startsWith(prefix)) {
+    throw new Error(`URI ${uri} is not inside team "${team}" shared subtree.`);
+  }
+  return uri.slice(prefix.length);
+}
+function stripPersonalProvenance(content) {
+  const lines = content.split("\n");
+  let headerEnd = lines.length;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].trim() === "") {
+      headerEnd = index;
+      break;
     }
-    try {
-      const parsed = JSON.parse(trimmedLine);
-      const text = legacyMessageText(parsed)?.trim();
-      if (text && isLegacyThreadnoteMemory(text)) {
-        memories.push(text);
-      }
-    } catch (_err) {
+  }
+  const cleaned = [];
+  for (let index = 0; index < headerEnd; index += 1) {
+    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
       continue;
     }
+    cleaned.push(lines[index]);
   }
-  return memories;
-}
-function legacyMessageText(value) {
-  if (!isJsonObject(value)) {
-    return void 0;
+  for (let index = headerEnd; index < lines.length; index += 1) {
+    cleaned.push(lines[index]);
   }
-  if (typeof value.content === "string") {
-    return value.content;
+  return cleaned.join("\n");
+}
+async function readMemoryContent(config, ov, uri, dryRun) {
+  const args = withIdentity(config, ["read", uri]);
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    return "<dry-run memory body>";
   }
-  if (!Array.isArray(value.parts)) {
-    return void 0;
+  const result = await runCommand(ov, args);
+  if (!result.stdout.trim()) {
+    throw new Error(`Refusing to publish empty memory at ${uri}`);
   }
-  const parts = value.parts.map((part) => isJsonObject(part) && part.type === "text" && typeof part.text === "string" ? part.text : void 0).filter((text) => text !== void 0);
-  return parts.length > 0 ? parts.join("\n") : void 0;
-}
-function isLegacyThreadnoteMemory(text) {
-  return text.startsWith("MEMORY\n") || text.startsWith("HANDOFF\n");
-}
-async function existingDurableMemoryHashes(config) {
-  const hashes = /* @__PURE__ */ new Set();
-  await collectDurableMemoryHashes(localVikingDataRoot(config), hashes);
-  return hashes;
+  return result.stdout;
 }
-async function collectDurableMemoryHashes(root, hashes) {
-  let entries;
-  try {
-    entries = await (0, import_promises4.readdir)(root, { withFileTypes: true });
-  } catch (_err) {
-    return;
-  }
-  for (const entry of entries) {
-    const path = (0, import_node_path4.join)(root, entry.name);
-    if (entry.isDirectory()) {
-      await collectDurableMemoryHashes(path, hashes);
+async function ensureSharedDirectoryChain(config, ov, memoryUri, dryRun, options = {}) {
+  const directoryUri = parentUri(memoryUri);
+  for (const uri of sharedDirectoryChain(config, directoryUri)) {
+    const args = withIdentity(config, ["stat", uri]);
+    if (dryRun) {
+      if (options.quiet !== true) {
+        console.log(`Would run: ${formatShellCommand(ov, args)}`);
+      }
       continue;
     }
-    if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md") || !isDurableMemoryPath(path)) {
+    const statResult = await runCommand(ov, args, { allowFailure: true });
+    if (statResult.exitCode === 0) {
       continue;
     }
-    const content = await readTextIfExists(path);
-    if (content) {
-      const trimmedContent = content.trim();
-      hashes.add(sha256(trimmedContent));
-      hashes.add(sha256(comparableMemoryText(trimmedContent)));
+    if (options.quiet === true) {
+      await runCommand(ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+    } else {
+      await maybeRun(false, ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared memories."]));
     }
   }
 }
-function isDurableMemoryPath(path) {
-  return path.split(import_node_path4.sep).includes("memories");
+function parentUri(uri) {
+  const lastSlash = uri.lastIndexOf("/");
+  return lastSlash === -1 ? uri : uri.slice(0, lastSlash);
 }
-async function childDirectoryNames(path) {
-  let entries;
-  try {
-    entries = await (0, import_promises4.readdir)(path, { withFileTypes: true });
-  } catch (_err) {
-    return [];
+function sharedDirectoryChain(config, directoryUri) {
+  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!directoryUri.startsWith(prefix)) {
+    return [directoryUri];
   }
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  const parts = directoryUri.slice(prefix.length).split("/").filter(Boolean);
+  const chain = [];
+  for (let index = 1; index <= parts.length; index += 1) {
+    chain.push(`${prefix}${parts.slice(0, index).join("/")}`);
+  }
+  return chain;
 }
-async function readTextIfExists(path) {
-  try {
-    const pathStat = await (0, import_promises4.stat)(path);
-    if (!pathStat.isFile()) {
-      return void 0;
+async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun, options = {}) {
+  if (dryRun) {
+    const args = withIdentity(config, [
+      "write",
+      uri,
+      "--from-file",
+      "<staged temp file>",
+      "--mode",
+      initialMode,
+      "--wait",
+      "--timeout",
+      "120"
+    ]);
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
     }
-    return await (0, import_promises4.readFile)(path, "utf8");
-  } catch (_err) {
-    return void 0;
+    return;
   }
-}
-function sensitiveMemoryReason(text) {
-  const patterns = [
-    { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    { name: "API key", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
-    { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
-    { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
-    { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ }
-  ];
-  return patterns.find((pattern) => pattern.regex.test(text))?.name;
-}
-function comparableMemoryText(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("MEMORY\n")) {
-    return trimmed;
+  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path4.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path4.join)(stagingDir, "body.txt");
+  try {
+    await (0, import_promises4.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await writeOvFileWithRetry(config, ov, uri, tempPath, initialMode, options);
+  } finally {
+    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
   }
-  const separatorIndex = trimmed.indexOf("\n\n");
-  return separatorIndex === -1 ? trimmed : trimmed.slice(separatorIndex + 2).trim();
-}
-function legacySourceLabel(candidate) {
-  return `${candidate.sourceAccount}/${candidate.sourceSession}/${candidate.sourceArchive}`;
-}
-function localVikingDataRoot(config) {
-  return (0, import_node_path4.join)(config.agentContextHome, "data", "viking");
-}
-function localUserMemoriesRoot(config) {
-  return (0, import_node_path4.join)(localVikingDataRoot(config), config.account, "user", uriSegment(config.user), "memories");
-}
-function uniqueStrings(values) {
-  return [...new Set(values)].sort();
 }
-function isResourceBusy(stderr, stdout) {
-  const output2 = `${stderr}
-${stdout}`.toLowerCase();
-  return output2.includes("resource is busy") || output2.includes("resource is being processed");
-}
-async function buildHandoff(options) {
-  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]) ?? getInvocationCwd();
-  const branch = await gitValue(["branch", "--show-current"], repoRoot) ?? "unknown";
-  const status = await gitValue(["status", "--short"], repoRoot) ?? "";
-  const diffStat = await gitValue(["diff", "--stat", "HEAD"], repoRoot) ?? "";
-  const touchedFiles = await gitTouchedFiles(repoRoot);
-  const repoName = (0, import_node_path4.basename)(repoRoot);
-  const metadata = {
-    kind: "handoff",
-    project: normalizeOptionalMetadata(options.project) ?? repoName,
-    sourceAgentClient: options.sourceAgentClient ?? "codex",
-    status: "active",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    topic: normalizeOptionalMetadata(options.topic)
-  };
-  const bodyText = [
-    `repo: ${repoName}`,
-    `repo_path: ${repoRoot}`,
-    `branch: ${branch || "unknown"}`,
-    `task: ${options.task ?? "unspecified"}`,
-    "",
-    "files_touched:",
-    formatBlock(touchedFiles, "- none"),
-    "",
-    "git_status:",
-    formatBlock(status, "- clean"),
-    "",
-    "diff_stat:",
-    formatBlock(diffStat, "- none"),
-    "",
-    "tests:",
-    options.tests ?? "- not recorded",
-    "",
-    "blockers:",
-    options.blockers ?? "- none recorded",
-    "",
-    "next_step:",
-    options.nextStep ?? "- inspect the current repo state and continue from this handoff"
-  ].join("\n");
-  return { bodyText, metadata };
-}
-async function gitTouchedFiles(cwd) {
-  const changedFiles = await gitValue(["diff", "--name-only", "HEAD"], cwd);
-  const untrackedFiles = await gitValue(["ls-files", "--others", "--exclude-standard"], cwd);
-  const files = /* @__PURE__ */ new Set();
-  for (const value of [changedFiles, untrackedFiles]) {
-    for (const line of (value ?? "").split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed) {
-        files.add(trimmed);
+async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, options = {}) {
+  const maxAttempts = 4;
+  const existedBeforeWrite = await vikingResourceExists(ov, config, uri);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config, uri);
+    const ourWriteLanded = existsNow && !existedBeforeWrite;
+    const mode = attempt === 0 ? initialMode : ourWriteLanded ? "replace" : initialMode;
+    const args = withIdentity(config, [
+      "write",
+      uri,
+      "--from-file",
+      fromFile,
+      "--mode",
+      mode,
+      "--wait",
+      "--timeout",
+      "120"
+    ]);
+    if (options.quiet !== true) {
+      console.log(`${attempt === 0 ? "Running" : "Retrying"}: ${formatShellCommand(ov, args)}`);
+    }
+    const result = await runCommand(ov, args, { allowFailure: true });
+    if (result.exitCode === 0) {
+      if (options.quiet !== true && result.stdout.trim()) {
+        console.log(result.stdout.trim());
+      }
+      if (options.quiet !== true && result.stderr.trim()) {
+        console.error(result.stderr.trim());
+      }
+      return;
+    }
+    if (isTransientOvFailure(result.stderr, result.stdout) && await vikingResourceExists(ov, config, uri) && !existedBeforeWrite) {
+      if (options.quiet !== true) {
+        console.log(
+          "OpenViking accepted the write but returned an error before the wait completed; draining the queue."
+        );
       }
+      await waitForOvQueue(ov, config, options);
+      return;
+    }
+    if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
+      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
+    }
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config, options);
+    } else {
+      await sleep(1e3 * (attempt + 1));
     }
   }
-  return [...files].sort().join("\n");
 }
-function formatBlock(value, emptyValue) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return emptyValue;
+async function waitForOvQueue(ov, config, options = {}) {
+  const result = await runCommand(ov, withIdentity(config, ["wait", "--timeout", "120"]), { allowFailure: true });
+  if (options.quiet !== true && result.stdout.trim()) {
+    console.log(result.stdout.trim());
+  }
+  if (options.quiet !== true && result.stderr.trim()) {
+    console.error(result.stderr.trim());
   }
-  return trimmed.split("\n").map((line) => `- ${line}`).join("\n");
 }
-
-// src/update-check.ts
-var import_node_child_process2 = require("node:child_process");
-var import_promises5 = require("node:fs/promises");
-var import_node_path5 = require("node:path");
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var NPM_LATEST_URL = "https://registry.npmjs.org/threadnote/latest";
-var FETCH_TIMEOUT_MS = 3e3;
-async function checkForThreadnoteUpdate(args) {
-  if (args.currentVersion === "unknown") {
-    return void 0;
+function isTransientOvFailure(stderr, stdout) {
+  const output2 = `${stderr}
+${stdout}`.toLowerCase();
+  return output2.includes("resource is busy") || output2.includes("resource is being processed") || output2.includes("network error") || output2.includes("error sending request") || output2.includes("http request failed") || output2.includes("connection refused") || output2.includes("connection reset") || output2.includes("timed out");
+}
+function isResourceBusyFailure(stderr, stdout) {
+  const output2 = `${stderr}
+${stdout}`.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;
   }
-  const cached = await readUpdateCache(args.cachePath);
-  if (cached && isCacheFresh(cached)) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+}
+async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
+  if (label !== "publish") {
+    return;
   }
-  const fresh = await fetchLatestVersion();
-  if (fresh) {
-    await writeUpdateCache(args.cachePath, {
-      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      latestVersion: fresh,
-      version: 1
-    });
-    return compareVersions(args.currentVersion, fresh);
+  const prefix = "viking://";
+  if (!rollbackUri.startsWith(prefix)) {
+    return;
   }
-  if (cached) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+  const parts = rollbackUri.slice(prefix.length).split("/");
+  const sharedIndex = parts.indexOf("shared");
+  if (sharedIndex === -1 || sharedIndex + 2 >= parts.length) {
+    return;
   }
-  return void 0;
+  const relative3 = parts.slice(sharedIndex + 2).join("/");
+  if (!relative3) {
+    return;
+  }
+  await (0, import_promises4.rm)((0, import_node_path4.join)(worktree, relative3), { force: true });
 }
-function spawnDetachedAutoUpdate() {
-  try {
-    const entry = process.argv[1];
-    if (typeof entry !== "string" || entry.length === 0) {
-      return;
+async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
+  const args = withIdentity(config, ["rm", uri]);
+  if (dryRun) {
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
     }
-    const child = (0, import_node_child_process2.spawn)(process.execPath, [entry, "update", "--yes"], {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.unref();
-  } catch {
+    return;
   }
-}
-function compareVersions(currentVersion, latestVersion) {
-  return {
-    currentVersion,
-    latestVersion,
-    outdated: isNewerVersion(latestVersion, currentVersion)
-  };
-}
-function isNewerVersion(candidate, baseline) {
-  const candidateParts = parseVersion(candidate);
-  const baselineParts = parseVersion(baseline);
-  for (let index = 0; index < 3; index += 1) {
-    if (candidateParts[index] !== baselineParts[index]) {
-      return candidateParts[index] > baselineParts[index];
+  const maxAttempts = 4;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const result = await runCommand(ov, args, { allowFailure: true });
+    if (result.exitCode === 0) {
+      if (options.quiet !== true && result.stdout.trim()) {
+        console.log(result.stdout.trim());
+      }
+      return;
+    }
+    if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
+      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
+    }
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config, options);
+    } else {
+      await sleep(1e3 * (attempt + 1));
     }
   }
-  return false;
 }
-function parseVersion(value) {
-  const parts = value.split(".").map((part) => parseInt(part, 10));
-  return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+async function vikingResourceExists(ov, config, uri) {
+  const result = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+  return result.exitCode === 0;
 }
-function isCacheFresh(cache) {
-  const checkedAt = new Date(cache.checkedAt).getTime();
-  return Number.isFinite(checkedAt) && Date.now() - checkedAt < CACHE_TTL_MS;
+async function hasUncommittedChanges(worktree) {
+  const result = await runCommand("git", ["-C", worktree, "status", "--porcelain"], { allowFailure: true });
+  return result.stdout.trim().length > 0;
 }
-async function readUpdateCache(cachePath) {
-  try {
-    const raw = await (0, import_promises5.readFile)(cachePath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== 1 || typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
-      return void 0;
-    }
-    return { checkedAt: parsed.checkedAt, latestVersion: parsed.latestVersion, version: 1 };
-  } catch {
+async function gitOutput(worktree, args, dryRun) {
+  if (dryRun) {
     return void 0;
   }
-}
-async function writeUpdateCache(cachePath, contents) {
-  try {
-    await (0, import_promises5.mkdir)((0, import_node_path5.dirname)(cachePath), { recursive: true });
-    await (0, import_promises5.writeFile)(cachePath, `${JSON.stringify(contents)}
-`, { encoding: "utf8", mode: 384 });
-  } catch {
-  }
-}
-async function fetchLatestVersion() {
-  try {
-    const response = await fetch(NPM_LATEST_URL, {
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      return void 0;
-    }
-    const data = await response.json();
-    return typeof data.version === "string" && data.version.length > 0 ? data.version : void 0;
-  } catch {
+  const result = await runCommand("git", ["-C", worktree, ...args], { allowFailure: true });
+  if (result.exitCode !== 0) {
     return void 0;
   }
+  return result.stdout.trim();
 }
-
-// src/version.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path6 = require("node:path");
-var cachedVersion;
-function getThreadnoteVersion() {
-  if (cachedVersion !== void 0) {
-    return cachedVersion;
-  }
-  try {
-    const packageJsonPath = (0, import_node_path6.join)(__dirname, "..", "package.json");
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf8"));
-    cachedVersion = typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown";
-  } catch {
-    cachedVersion = "unknown";
-  }
-  return cachedVersion;
-}
-
-// src/hooks.ts
-var MANAGED_HOOKS = [
-  {
-    event: "PreCompact",
-    command: HOOK_PRE_COMPACT_COMMAND,
-    description: "Auto-store a handoff snapshot before context compaction so the next turn can recall it."
-  },
-  {
-    event: "SessionStart",
-    command: HOOK_SESSION_START_COMMAND,
-    description: "Pre-load the latest handoff for the current repo into the new session context."
-  }
-];
-async function runHooksInstall(config, agent, options) {
-  const apply = options.apply === true && options.dryRun !== true;
-  const remove = options.remove === true;
-  switch (agent) {
-    case "claude":
-      await runClaudeHooksInstall({ apply, remove });
-      return;
-    case "codex":
-      printCodexHooksNotice(remove);
-      return;
-    case "cursor":
-      printNoHooksSupported("cursor", remove);
-      return;
-    case "copilot":
-      printNoHooksSupported("copilot", remove);
-      return;
-  }
-}
-async function runClaudeHooksInstall(options) {
-  const path = expandPath(CLAUDE_SETTINGS_PATH);
-  const existingRaw = await exists(path) ? await (0, import_promises6.readFile)(path, "utf8") : "{}";
-  const parsed = parseJsonConfigObject(existingRaw) ?? {};
-  const next = options.remove ? withoutThreadnoteHooks(parsed) : withThreadnoteHooks(parsed);
-  const before = JSON.stringify(parsed);
-  const after = JSON.stringify(next);
-  if (before === after) {
-    console.log(`Claude hooks already ${options.remove ? "absent" : "managed"} in ${path}.`);
-    return;
-  }
-  console.log(`${options.apply ? "Updating" : "Would update"} ${path}:`);
-  for (const entry of MANAGED_HOOKS) {
-    console.log(`  ${options.remove ? "-" : "+"} ${entry.event}: ${entry.command}`);
-  }
-  if (!options.apply) {
-    console.log("\nRe-run with --apply to actually modify the file.");
-    return;
+async function listChangedFiles(worktree, beforeRev, afterRev) {
+  const result = await runCommand("git", ["-C", worktree, "diff", "--name-status", "-z", `${beforeRev}..${afterRev}`], {
+    allowFailure: true
+  });
+  if (result.exitCode !== 0) {
+    return [];
   }
-  await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(path), { recursive: true });
-  const serialized = `${JSON.stringify(next, void 0, 2)}
-`;
-  await (0, import_promises6.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
-  await (0, import_promises6.chmod)(path, 384);
-  console.log(`${options.remove ? "Removed" : "Installed"} threadnote-managed Claude hooks.`);
-}
-function withThreadnoteHooks(input2) {
-  const hooks = ensureMutableObject(input2.hooks);
-  for (const entry of MANAGED_HOOKS) {
-    const list = ensureMutableArray(hooks[entry.event]).filter((item) => !isManagedThreadnoteEntry(item));
-    list.push({
-      [THREADNOTE_HOOK_MARKER]: THREADNOTE_HOOK_MARKER_VALUE,
-      matcher: "",
-      hooks: [{ type: "command", command: entry.command }]
-    });
-    hooks[entry.event] = list;
+  const entries = result.stdout.split("\0").filter((part) => part.length > 0);
+  const changes = [];
+  for (let index = 0; index < entries.length; ) {
+    const raw = entries[index];
+    const head = raw.slice(0, 1);
+    if (head === "R" || head === "C") {
+      const oldRel = entries[index + 1];
+      const newRel = entries[index + 2];
+      if (oldRel && newRel) {
+        changes.push({ path: (0, import_node_path4.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path4.join)(worktree, newRel), relativePath: newRel, status: "added" });
+      }
+      index += 3;
+      continue;
+    }
+    const rel = entries[index + 1];
+    if (rel) {
+      const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
+      changes.push({ path: (0, import_node_path4.join)(worktree, rel), relativePath: rel, status });
+    }
+    index += 2;
   }
-  return { ...input2, hooks };
+  return changes;
 }
-function withoutThreadnoteHooks(input2) {
-  if (!isJsonObject(input2.hooks)) {
-    return input2;
-  }
-  const hooks = {};
-  for (const [event, value] of Object.entries(input2.hooks)) {
-    if (!Array.isArray(value)) {
-      hooks[event] = value;
+async function applyChangesToOpenViking(config, team, changes, options = {}) {
+  const ov = await openVikingCliForMode(false);
+  for (const change of changes) {
+    if (!change.relativePath.endsWith(".md")) {
       continue;
     }
-    const filtered = value.filter((item) => !isManagedThreadnoteEntry(item));
-    if (filtered.length > 0) {
-      hooks[event] = filtered;
+    const firstSegment = change.relativePath.split("/")[0];
+    if (!SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment)) {
+      continue;
     }
+    const uri = workfileToVikingUri(config, team, change.path);
+    if (change.status === "removed") {
+      await removeMemoryUri(config, ov, uri, false, options);
+      continue;
+    }
+    if (!await isFile(change.path)) {
+      continue;
+    }
+    const ovHasResource = await vikingResourceExists(ov, config, uri);
+    if (ovHasResource) {
+      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+      if (options.quiet !== true) {
+        console.warn(`share sync: ${uri}: ${reason}.`);
+      }
+    }
+    await ensureSharedDirectoryChain(config, ov, uri, false, options);
+    const writeMode = ovHasResource ? "replace" : "create";
+    await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
   }
-  if (Object.keys(hooks).length === 0) {
-    const next = { ...input2 };
-    delete next.hooks;
-    return next;
-  }
-  return { ...input2, hooks };
-}
-function isManagedThreadnoteEntry(value) {
-  return isJsonObject(value) && value[THREADNOTE_HOOK_MARKER] === THREADNOTE_HOOK_MARKER_VALUE;
 }
-function ensureMutableObject(value) {
-  return isJsonObject(value) ? { ...value } : {};
-}
-function ensureMutableArray(value) {
-  return Array.isArray(value) ? [...value] : [];
+
+// src/memory.ts
+function parseMemoryKind(value) {
+  if (["durable", "handoff", "incident", "preference", "smoke"].includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported memory kind "${value}". Expected durable, handoff, incident, preference, or smoke.`);
 }
-function printCodexHooksNotice(remove) {
-  if (remove) {
-    console.log("Codex CLI does not expose a managed hook surface today, so there is nothing to remove.");
-    return;
+function parseMemoryStatus(value) {
+  if (["active", "archived", "superseded"].includes(value)) {
+    return value;
   }
-  console.log(
-    [
-      "Codex CLI does not currently expose lifecycle hooks (no PreCompact or SessionStart analog).",
-      "Threadnote already installs Codex user instructions at ~/.codex/AGENTS.md; that remains the active guidance surface.",
-      "If a future Codex release adds hook events, threadnote will pick them up via `install-hooks codex`."
-    ].join("\n")
-  );
+  throw new Error(`Unsupported memory status "${value}". Expected active, archived, or superseded.`);
 }
-function printNoHooksSupported(agent, remove) {
-  if (remove) {
-    console.log(`${agent} does not expose a hook surface; nothing to remove.`);
-    return;
+async function runRemember(config, options) {
+  const text = await getInputText(options.text, options.stdin === true);
+  if (!text.trim()) {
+    throw new Error("Provide memory text with --text or --stdin.");
   }
-  console.log(
-    [
-      `${agent} does not expose agent-mode hooks today.`,
-      "Threadnote already installs user-level instructions for this agent; that remains the active guidance surface.",
-      "Hooks support will be added if the agent gains a hook surface upstream."
-    ].join("\n")
-  );
+  const metadata = {
+    kind: options.kind ?? "durable",
+    project: normalizeOptionalMetadata(options.project),
+    sourceAgentClient: options.sourceAgentClient ?? "codex",
+    status: options.status ?? "active",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    topic: normalizeOptionalMetadata(options.topic)
+  };
+  await storeMemory(config, {
+    bodyText: text.trim(),
+    dryRun: options.dryRun === true,
+    metadata,
+    replaceUri: options.replace,
+    title: "MEMORY"
+  });
 }
-async function hasManagedClaudeHooks() {
-  const path = expandPath(CLAUDE_SETTINGS_PATH);
-  if (!await exists(path)) {
-    return false;
+async function runMigrateMemories(config, options) {
+  const dryRun = options.dryRun === true;
+  const limit = options.limit ? parsePositiveInteger(options.limit, "migration limit") : void 0;
+  const sourceAccounts = await legacySourceAccounts(config, options);
+  if (sourceAccounts.length === 0) {
+    console.log("No local OpenViking accounts found to scan.");
+    return;
   }
-  const raw = await (0, import_promises6.readFile)(path, "utf8");
-  const parsed = parseJsonConfigObject(raw);
-  if (!parsed || !isJsonObject(parsed.hooks)) {
-    return false;
+  const candidates = await legacyMemoryCandidates(config, sourceAccounts);
+  const existingHashes = await existingDurableMemoryHashes(config);
+  const ov = await openVikingCliForMode(dryRun);
+  const migrationPath = (0, import_node_path5.join)(config.agentContextHome, "legacy-memory-migration.txt");
+  let duplicateCount = 0;
+  let migratedCount = 0;
+  let sensitiveCount = 0;
+  if (!dryRun && candidates.length > 0) {
+    await ensureDurableMemoryDirectory(ov, config);
   }
-  for (const value of Object.values(parsed.hooks)) {
-    if (!Array.isArray(value)) {
-      continue;
+  try {
+    for (const candidate of candidates) {
+      if (existingHashes.has(candidate.hash)) {
+        duplicateCount += 1;
+        continue;
+      }
+      if (existingHashes.has(candidate.comparableHash)) {
+        duplicateCount += 1;
+        continue;
+      }
+      const sensitiveReason = sensitiveMemoryReason(candidate.text);
+      if (sensitiveReason) {
+        sensitiveCount += 1;
+        console.log(
+          `SKIP ${legacySourceLabel(candidate)}: possible ${sensitiveReason}; inspect the source archive manually if needed.`
+        );
+        continue;
+      }
+      if (limit !== void 0 && migratedCount >= limit) {
+        break;
+      }
+      const memoryUri = migratedDurableMemoryUri(config, candidate.hash);
+      if (!dryRun && await vikingResourceExists2(ov, config, memoryUri)) {
+        duplicateCount += 1;
+        existingHashes.add(candidate.hash);
+        continue;
+      }
+      console.log(`${dryRun ? "Would migrate" : "Migrating"} ${legacySourceLabel(candidate)} -> ${memoryUri}`);
+      if (!dryRun) {
+        await (0, import_promises5.writeFile)(migrationPath, candidate.text, { encoding: "utf8", mode: 384 });
+        await (0, import_promises5.chmod)(migrationPath, 384);
+        await writeDurableMemoryFile(ov, config, memoryUri, migrationPath, "create");
+        existingHashes.add(candidate.hash);
+      }
+      migratedCount += 1;
     }
-    if (value.some((item) => isManagedThreadnoteEntry(item))) {
-      return true;
+  } finally {
+    if (!dryRun) {
+      await (0, import_promises5.rm)(migrationPath, { force: true });
     }
   }
-  return false;
-}
-async function runPreCompactHook(config, options = {}) {
-  try {
-    const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
-    const project = repoRoot ? (0, import_node_path7.basename)(repoRoot) : "general";
-    await runHandoff(config, {
-      blockers: "- none recorded",
-      dryRun: options.dryRun === true,
-      nextStep: "Continue from this auto-snapshot. A manual `threadnote handoff` will produce a richer write-up if you have more context.",
-      project,
-      sourceAgentClient: "claude",
-      task: "Auto-snapshot captured at Claude PreCompact (deterministic safety net before context compaction).",
-      tests: "- not recorded (auto-snapshot)",
-      topic: HOOK_AUTO_PRECOMPACT_TOPIC
-    });
-  } catch (err) {
-    process.stderr.write(
-      `threadnote pre-compact-hook: snapshot skipped (${err instanceof Error ? err.message : String(err)})
-`
-    );
-  }
-}
-async function runSessionStartHook(config, options = {}) {
-  try {
-    const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
-    if (!repoRoot) {
-      return;
-    }
-    const project = (0, import_node_path7.basename)(repoRoot);
-    await emitUpdateBannerIfOutdated(config);
-    process.stdout.write(`## Threadnote \u2014 latest context for ${project}
-
-`);
-    await runRecall(config, {
-      dryRun: options.dryRun === true,
-      inferScope: true,
-      nodeLimit: "5",
-      query: `${project} latest handoff durable feature memory`
-    });
-  } catch (err) {
-    process.stderr.write(
-      `threadnote session-start-hook: recall skipped (${err instanceof Error ? err.message : String(err)})
-`
-    );
-  }
-}
-async function emitUpdateBannerIfOutdated(config) {
-  try {
-    const result = await checkForThreadnoteUpdate({
-      cachePath: (0, import_node_path7.join)(config.agentContextHome, ".update-state.json"),
-      currentVersion: getThreadnoteVersion()
-    });
-    if (!result || !result.outdated) {
-      return;
-    }
-    if (process.env.THREADNOTE_AUTO_UPDATE === "1") {
-      process.stdout.write(
-        `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Auto-updating in the background; the new version takes effect next session.
-
-`
-      );
-      spawnDetachedAutoUpdate();
-      return;
-    }
-    process.stdout.write(
-      `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Run: threadnote update
-
-`
-    );
-  } catch {
-  }
+  console.log(
+    [
+      `Migration summary: ${migratedCount} ${dryRun ? "would be migrated" : "migrated"}`,
+      `${duplicateCount} duplicate(s) skipped`,
+      `${sensitiveCount} sensitive-looking item(s) skipped`,
+      `${candidates.length} legacy Threadnote item(s) scanned`,
+      `source account(s): ${sourceAccounts.join(", ")}`
+    ].join("; ")
+  );
 }
-
-// src/seeding.ts
-var import_promises7 = require("node:fs/promises");
-var import_node_path8 = require("node:path");
-async function runSeed(config, options) {
-  const manifest = await readSeedManifest(config.manifestPath);
-  const ignorePatterns = await loadIgnorePatterns();
-  const ov = await openVikingCliForMode(options.dryRun === true);
-  const statePath = (0, import_node_path8.join)(config.agentContextHome, SEED_STATE_FILE);
-  const state = options.force === true ? { files: {}, version: 1 } : await readSeedState(statePath);
-  const projects = filterProjects(manifest.projects, options.only);
-  let importedCount = 0;
+async function runMigrateLifecycle(config, options) {
+  const dryRun = options.dryRun === true || options.apply !== true;
+  const limit = options.limit ? parsePositiveInteger(options.limit, "lifecycle migration limit") : void 0;
+  const ov = await openVikingCliForMode(dryRun);
+  const candidates = await legacyLifecycleHandoffCandidates(config);
+  const migrationPath = (0, import_node_path5.join)(config.agentContextHome, "lifecycle-memory-migration.txt");
+  let existingCount = 0;
+  let migratedCount = 0;
   let skippedCount = 0;
-  let unchangedCount = 0;
-  for (const project of projects) {
-    const projectRoot = expandPath(project.path);
-    if (!await exists(projectRoot)) {
-      console.log(`WARN project missing: ${project.name} (${projectRoot})`);
-      continue;
-    }
-    const candidates = await collectSeedCandidates(project, projectRoot, ignorePatterns);
+  try {
     for (const candidate of candidates) {
-      const fileStat = await statSeedFile(candidate.filePath);
-      const recorded = state.files[candidate.destinationUri];
-      if (fileStat && recorded && recorded.mtimeMs === fileStat.mtimeMs && recorded.size === fileStat.size) {
-        unchangedCount += 1;
-        continue;
-      }
-      const importPath = await prepareSeedFile(config, candidate, options.dryRun === true);
-      if (!importPath) {
-        skippedCount += 1;
-        continue;
+      if (limit !== void 0 && migratedCount >= limit) {
+        break;
       }
-      const args = withIdentity(config, ["add-resource", importPath, "--to", candidate.destinationUri, "--wait"]);
-      await maybeRun(options.dryRun === true, ov, args);
-      importedCount += 1;
-      if (fileStat && options.dryRun !== true) {
-        state.files[candidate.destinationUri] = { mtimeMs: fileStat.mtimeMs, size: fileStat.size };
+      const destinationUri = lifecycleMigrationUri(config, candidate.metadata, sha256(candidate.original.trim()));
+      const migratedMemory = formatMemoryDocument(
+        "HANDOFF",
+        candidate.metadata,
+        ["Migrated legacy handoff from the historical events trail.", "", candidate.original.trim()].join("\n")
+      );
+      console.log(`${dryRun ? "Would migrate" : "Migrating"} ${candidate.sourceUri} -> ${destinationUri}`);
+      if (!dryRun) {
+        if (await vikingResourceExists2(ov, config, destinationUri)) {
+          existingCount += 1;
+          console.log(`Archived copy already exists; cleaning up legacy source: ${candidate.sourceUri}`);
+        } else {
+          await (0, import_promises5.writeFile)(migrationPath, migratedMemory, { encoding: "utf8", mode: 384 });
+          await (0, import_promises5.chmod)(migrationPath, 384);
+          await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, candidate.metadata));
+          await writeDurableMemoryFile(ov, config, destinationUri, migrationPath, "create");
+        }
+        const removedOriginal = await removeVikingResourceWithRetry(ov, config, candidate.sourceUri);
+        if (!removedOriginal) {
+          console.error(
+            `Migrated copy stored, but original is still processing. Retry later: threadnote forget ${candidate.sourceUri}`
+          );
+          skippedCount += 1;
+        }
       }
+      migratedCount += 1;
+    }
+  } finally {
+    if (!dryRun) {
+      await (0, import_promises5.rm)(migrationPath, { force: true });
     }
-  }
-  if (options.dryRun !== true) {
-    await writeSeedState(statePath, state);
   }
   console.log(
-    `Seed complete: ${importedCount} candidate(s), ${unchangedCount} unchanged, ${skippedCount} skipped for safety.`
+    [
+      `Lifecycle migration summary: ${migratedCount} clear legacy handoff(s) ${dryRun ? "would be migrated" : "migrated"}`,
+      `${existingCount} existing archived copy/copies reused`,
+      `${skippedCount} legacy source(s) still processing`,
+      `${candidates.length} clear legacy handoff candidate(s) found`,
+      dryRun ? "Run with --apply to perform this migration." : void 0
+    ].filter((part) => part !== void 0).join("; ")
   );
 }
-function filterProjects(projects, only) {
-  if (!only || only.length === 0) {
-    return projects;
+async function runRecall(config, options) {
+  if (options.dryRun !== true) {
+    await syncSharedReposAndLog(config);
   }
-  const known = new Set(projects.map((project) => project.name));
-  const missing = only.filter((name) => !known.has(name));
-  if (missing.length > 0) {
-    const all = [...known].join(", ");
-    throw new Error(`Unknown project(s) in --only: ${missing.join(", ")}. Manifest projects: ${all}`);
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, options.query));
+  const args = ["search", options.query];
+  if (inferredUri) {
+    args.push("--uri", inferredUri);
+    console.log(`Recall scope: ${inferredUri}`);
   }
-  const want = new Set(only);
-  return projects.filter((project) => want.has(project.name));
+  if (options.nodeLimit) {
+    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  }
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  await augmentRecallWithSeededResources(config, ov, options, inferredUri);
+  await printExactMemoryMatches(config, ov, options.query, {
+    dryRun: options.dryRun === true,
+    includeArchived: options.includeArchived === true
+  });
 }
-async function statSeedFile(path) {
-  try {
-    const result = await (0, import_promises7.stat)(path);
-    return { mtimeMs: result.mtimeMs, size: result.size };
-  } catch (_err) {
-    return void 0;
+async function augmentRecallWithSeededResources(config, ov, options, inferredUri) {
+  if (options.uri || options.inferScope === false) {
+    return;
+  }
+  const project = await inferProjectFromQuery(config.manifestPath, options.query);
+  if (!project) {
+    return;
+  }
+  const projectResourceUri = trimTrailingSlash(project.uri);
+  if (!projectResourceUri.startsWith("viking://") || projectResourceUri === inferredUri) {
+    return;
+  }
+  const args = ["search", options.query, "--uri", projectResourceUri];
+  if (options.nodeLimit) {
+    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
   }
+  console.log(`
+Also searching seeded resources: ${projectResourceUri}`);
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
 }
-async function readSeedState(path) {
+async function runRead(config, uri, options) {
+  assertVikingUri(uri);
+  if (options.dryRun !== true) {
+    await syncSharedReposAndLog(config);
+  }
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const result = await maybeRun(options.dryRun === true, ov, withIdentity(config, ["read", uri]));
+  if (result && result.stdout.includes("[Directory overview is not ready]") && (uri.endsWith("/.overview.md") || uri.endsWith("/.abstract.md"))) {
+    const parentUri2 = parentVikingUri(uri);
+    console.log("\nThis is a generated summary placeholder. To read the underlying content, inspect leaf nodes:");
+    console.log(`  threadnote list ${parentUri2} --all --recursive`);
+  }
+}
+async function syncSharedReposAndLog(config) {
   try {
-    const raw = await (0, import_promises7.readFile)(path, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== 1 || !isJsonObject(parsed.files)) {
-      return { files: {}, version: 1 };
+    const syncResult = await syncSharedReposBeforeAgentRead(config);
+    if (syncResult.syncedTeams.length > 0) {
+      console.error(`Auto-synced shared memories: ${syncResult.syncedTeams.join(", ")}`);
     }
-    const files = {};
-    for (const [uri, entry] of Object.entries(parsed.files)) {
-      if (isJsonObject(entry) && typeof entry.mtimeMs === "number" && typeof entry.size === "number") {
-        files[uri] = { mtimeMs: entry.mtimeMs, size: entry.size };
-      }
+    for (const warning of syncResult.warnings) {
+      console.error(`Auto-sync warning: ${warning}`);
     }
-    return { files, version: 1 };
-  } catch (_err) {
-    return { files: {}, version: 1 };
+  } catch (err) {
+    console.error(`Auto-sync warning: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function writeSeedState(path, state) {
-  await ensureDirectory((0, import_node_path8.dirname)(path), false);
-  await (0, import_promises7.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
-`, { encoding: "utf8", mode: 384 });
-}
-async function runInitManifest(config, options) {
-  const manifestPath = expandPath(
-    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path8.join)(config.agentContextHome, USER_MANIFEST_NAME)
-  );
-  const repoInputs = options.repo && options.repo.length > 0 ? options.repo : [getInvocationCwd()];
-  const existingManifest = options.replace === true || !await exists(manifestPath) ? void 0 : await readSeedManifest(manifestPath);
-  const existingProjects = existingManifest?.projects ?? [];
-  const projects = [...existingProjects];
-  const seen = /* @__PURE__ */ new Set();
-  for (const project of existingProjects) {
-    seen.add(await projectIdentity(project.path));
+async function runList(config, uri, options) {
+  assertVikingUri(uri);
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const args = ["ls", uri];
+  if (options.all === true) {
+    args.push("--all");
   }
-  for (const repoInput of repoInputs) {
-    const repoRoot = await resolveRepoRoot(repoInput);
-    const identity = await projectIdentity(repoRoot);
-    if (seen.has(identity)) {
-      console.log(`Already in manifest: ${repoRoot}`);
-      continue;
-    }
-    seen.add(identity);
-    projects.push(projectManifestForRepo(repoRoot, projects));
+  if (options.recursive === true) {
+    args.push("--recursive");
   }
-  const outputManifest = {
-    version: 1,
-    projects: projects.map((project) => ({
-      name: project.name,
-      path: project.path,
-      uri: project.uri,
-      seed: [...project.seed]
-    }))
-  };
-  if (existingManifest?.futureMonorepo) {
-    const futureMonorepoKey = "future_monorepo";
-    const pathCandidatesKey = "path_candidates";
-    outputManifest[futureMonorepoKey] = {
-      [pathCandidatesKey]: [...existingManifest.futureMonorepo.pathCandidates],
-      uri: existingManifest.futureMonorepo.uri
-    };
+  if (options.simple === true) {
+    args.push("--simple");
   }
-  const output2 = jsYaml.dump(outputManifest, { lineWidth: 120, noRefs: true });
-  if (options.dryRun === true) {
-    console.log(`# Would write ${manifestPath}`);
-    console.log(output2.trimEnd());
-    return;
+  if (options.nodeLimit) {
+    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
   }
-  await ensureDirectory((0, import_node_path8.dirname)(manifestPath), false);
-  await (0, import_promises7.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises7.chmod)(manifestPath, 384);
-  console.log(`Wrote manifest: ${manifestPath}`);
-  console.log("Seed with:");
-  console.log("  threadnote seed --dry-run");
-  console.log("  threadnote seed");
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
 }
-async function runSeedSkills(config, options) {
+async function runHandoff(config, options) {
+  const { bodyText, metadata } = await buildHandoff(options);
+  await storeMemory(config, {
+    bodyText,
+    dryRun: options.dryRun === true,
+    metadata,
+    replaceUri: options.replace,
+    title: "HANDOFF"
+  });
+}
+async function runArchive(config, uri, options) {
+  assertVikingUri(uri);
   const ov = await openVikingCliForMode(options.dryRun === true);
-  const skills = await collectSkillCandidates(config);
-  const nativeMode = options.native === true;
-  console.log(
-    nativeMode ? "Skill seed mode: native OpenViking skills. This requires a working VLM config." : "Skill seed mode: resource catalog. Use --native only after configuring a working VLM provider."
-  );
-  for (const skill of skills) {
-    console.log(`Skill ${skill.source}: ${skill.filePath}`);
-    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : ["add-resource", skill.filePath, "--to", skillResourceUri(skill), "--wait"];
-    await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  const readResult = await maybeRun(options.dryRun === true, ov, withIdentity(config, ["read", uri]));
+  const original = readResult?.stdout.trim();
+  if (options.dryRun === true) {
+    const fallbackMetadata = {
+      archivedFrom: uri,
+      kind: options.kind ?? "handoff",
+      project: normalizeOptionalMetadata(options.project),
+      sourceAgentClient: "threadnote",
+      status: "archived",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      topic: normalizeOptionalMetadata(options.topic)
+    };
+    await storeMemory(config, {
+      bodyText: ["Archived original Threadnote memory.", "", "<original memory content would be read here>"].join("\n"),
+      dryRun: true,
+      metadata: fallbackMetadata,
+      title: "MEMORY"
+    });
+    console.log(formatShellCommand(ov, withIdentity(config, ["rm", uri])));
+    return;
   }
-  console.log(`Skill seed complete: ${skills.length} unique skill(s).`);
-}
-async function resolveRepoRoot(repoInput) {
-  const inputPath = expandPath(repoInput);
-  if (!await isDirectory(inputPath)) {
-    throw new Error(`Repo path is not a directory: ${inputPath}`);
+  if (!original) {
+    throw new Error(`Could not read ${uri} before archiving.`);
   }
-  return await gitValue(["rev-parse", "--show-toplevel"], inputPath) ?? inputPath;
-}
-async function projectIdentity(path) {
-  const expanded = expandPath(path);
-  try {
-    return await (0, import_promises7.realpath)(expanded);
-  } catch (_err) {
-    return expanded;
+  const inferredMetadata = inferMemoryMetadata(original);
+  const metadata = {
+    archivedFrom: uri,
+    kind: options.kind ?? inferredMetadata.kind ?? "handoff",
+    project: normalizeOptionalMetadata(options.project) ?? inferredMetadata.project,
+    sourceAgentClient: "threadnote",
+    status: "archived",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    topic: normalizeOptionalMetadata(options.topic) ?? inferredMetadata.topic
+  };
+  await storeMemory(config, {
+    bodyText: ["Archived original Threadnote memory.", "", original].join("\n"),
+    dryRun: false,
+    metadata,
+    title: "MEMORY"
+  });
+  const removedOriginal = await removeVikingResourceWithRetry(ov, config, uri);
+  if (removedOriginal) {
+    console.log(`Archived original memory: ${uri}`);
+  } else {
+    console.error(`Archive stored, but original memory is still processing. Retry later: threadnote forget ${uri}`);
   }
 }
-function projectManifestForRepo(repoRoot, existingProjects) {
-  const baseName = uriSegment((0, import_node_path8.basename)(repoRoot));
-  const usedNames = new Set(existingProjects.map((project) => project.name));
-  const usedUris = new Set(existingProjects.map((project) => project.uri));
-  let name = baseName;
-  let uri = `viking://resources/repos/${name}`;
-  if (usedNames.has(name) || usedUris.has(uri)) {
-    name = `${baseName}-${sha256(repoRoot).slice(0, 8)}`;
-    uri = `viking://resources/repos/${name}`;
+async function runForget(config, uri, options) {
+  assertVikingUri(uri);
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  if (options.dryRun === true) {
+    await maybeRun(true, ov, withIdentity(config, ["rm", uri]));
+    return;
   }
-  return {
-    name,
-    path: portablePath(repoRoot),
-    seed: DEFAULT_SEED_PATTERNS,
-    uri
-  };
-}
-async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const pattern of project.seed) {
-    const files = await resolveProjectPattern(projectRoot, pattern);
-    for (const filePath of files) {
-      const relativePath = toPosixPath((0, import_node_path8.relative)(projectRoot, filePath));
-      if (seen.has(relativePath) || matchesIgnore(relativePath, ignorePatterns)) {
-        continue;
-      }
-      seen.add(relativePath);
-      candidates.push({
-        destinationUri: `${trimTrailingSlash(project.uri)}/${relativePath}`,
-        filePath,
-        projectName: project.name,
-        relativePath
-      });
-    }
+  const removed = await removeVikingResourceWithRetry(ov, config, uri);
+  if (!removed) {
+    throw new Error(`Resource is still being processed; retry later: threadnote forget ${uri}`);
   }
-  return candidates;
 }
-async function resolveProjectPattern(projectRoot, pattern) {
-  const normalizedPattern = toPosixPath(pattern);
-  if (!hasGlob(normalizedPattern)) {
-    const filePath = (0, import_node_path8.join)(projectRoot, normalizedPattern);
-    return await isFile(filePath) ? [filePath] : [];
-  }
-  const globBase = getGlobBase(normalizedPattern);
-  const basePath = (0, import_node_path8.join)(projectRoot, globBase);
-  if (!await exists(basePath)) {
-    return [];
+async function runExportPack(config, options) {
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const defaultPath = (0, import_node_path5.join)(config.agentContextHome, `threadnote-${safeTimestamp()}.ovpack`);
+  const outputPath = expandPath(options.path ?? defaultPath);
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, ["export", options.uri ?? "viking://", outputPath]));
+}
+async function runImportPack(config, options) {
+  if (!options.path) {
+    throw new Error("Provide --path for import-pack.");
   }
-  const regex = globToRegExp(normalizedPattern);
-  const files = await walkFiles(basePath);
-  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path8.relative)(projectRoot, filePath))));
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  await maybeRun(
+    options.dryRun === true,
+    ov,
+    withIdentity(config, ["import", expandPath(options.path), options.targetUri ?? "viking://"])
+  );
 }
-async function prepareSeedFile(config, candidate, dryRun) {
-  const content = await (0, import_promises7.readFile)(candidate.filePath, "utf8");
-  const redactedContent = shouldRedactPath(candidate.relativePath) ? redactContent(candidate.relativePath, content) : content;
-  const secretMatches = detectSecretMatches(redactedContent);
-  if (secretMatches.length > 0) {
-    console.log(
-      `SKIP ${candidate.projectName}/${candidate.relativePath}: possible secret (${secretMatches.slice(0, MAX_SECRET_MATCHES_TO_PRINT).join(", ")})`
-    );
+async function inferRecallUri(config, query) {
+  if (!/\bskills?\b/.test(query.toLowerCase())) {
     return void 0;
   }
-  if (redactedContent === content) {
-    return candidate.filePath;
-  }
-  const redactedPath = (0, import_node_path8.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
-  if (dryRun) {
-    console.log(`Would write redacted copy: ${redactedPath}`);
-    return redactedPath;
-  }
-  await ensureDirectory((0, import_node_path8.dirname)(redactedPath), false);
-  await (0, import_promises7.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
-  await (0, import_promises7.chmod)(redactedPath, 384);
-  return redactedPath;
+  const project = await inferProjectFromQuery(config.manifestPath, query);
+  return project ? `viking://resources/agent-skills/repo-local-${uriSegment(project.name)}` : "viking://resources/agent-skills";
 }
-async function collectSkillCandidates(config) {
-  const sources = [
-    { pattern: "~/.codex/skills/**/SKILL.md", source: "codex-global" },
-    { pattern: "~/.codex/plugins/cache/**/skills/**/SKILL.md", source: "codex-plugin-cache" },
-    { pattern: "~/.claude/skills/**/SKILL.md", source: "claude-global" }
-  ];
-  try {
-    const manifest = await readSeedManifest(config.manifestPath);
-    for (const project of manifest.projects) {
-      sources.push({
-        pattern: `${project.path}/.claude/skills/**/SKILL.md`,
-        source: `repo-local:${project.name}`
-      });
-    }
-  } catch (err) {
-    console.log(`WARN cannot read manifest for repo-local skill discovery: ${errorMessage(err)}`);
+async function printExactMemoryMatches(config, ov, query, options) {
+  const terms = exactRecallTerms(query);
+  if (terms.length === 0) {
+    return;
   }
-  const seenHashes = /* @__PURE__ */ new Set();
-  const skills = [];
-  for (const source of sources) {
-    const files = await resolveAbsolutePattern(expandPath(source.pattern));
-    for (const filePath of files) {
-      const content = await (0, import_promises7.readFile)(filePath, "utf8");
-      const matches = detectSecretMatches(content);
-      if (matches.length > 0) {
-        console.log(`SKIP skill with possible secret: ${filePath}`);
+  const scopes = exactMemoryScopes(config, options.includeArchived);
+  const outputs = [];
+  for (const term of terms) {
+    for (const scope of scopes) {
+      const args = withIdentity(config, ["grep", term, "--uri", scope, "--node-limit", "5"]);
+      if (options.dryRun) {
+        outputs.push(formatShellCommand(ov, args));
         continue;
       }
-      const hash = sha256(content);
-      if (seenHashes.has(hash)) {
-        continue;
+      const result = await runCommand(ov, args, { allowFailure: true });
+      const output2 = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+      if (result.exitCode === 0 && grepOutputHasMatches(output2)) {
+        outputs.push(output2);
       }
-      seenHashes.add(hash);
-      skills.push({ filePath, hash, source: source.source });
     }
   }
-  return skills;
+  if (outputs.length === 0) {
+    return;
+  }
+  console.log("\nExact durable memory matches:");
+  console.log(outputs.join("\n\n"));
 }
-async function resolveAbsolutePattern(pattern) {
-  const normalizedPattern = toPosixPath(pattern);
-  if (!hasGlob(normalizedPattern)) {
-    return await isFile(normalizedPattern) ? [normalizedPattern] : [];
+async function storeMemory(config, options) {
+  if (options.replaceUri) {
+    assertVikingUri(options.replaceUri);
   }
-  const globBase = getGlobBase(normalizedPattern);
-  const basePath = globBase.startsWith("/") ? globBase : `/${globBase}`;
-  if (!await exists(basePath)) {
-    return [];
+  const ov = await openVikingCliForMode(options.dryRun);
+  const memoryPath = (0, import_node_path5.join)(config.agentContextHome, "last-memory.txt");
+  const candidateMetadata = { ...options.metadata, supersedes: options.replaceUri };
+  const candidateMemory = formatMemoryDocument(options.title, candidateMetadata, options.bodyText);
+  const memoryUri = memoryUriFor(config, candidateMemory, candidateMetadata);
+  const isInPlaceUpdate = options.replaceUri !== void 0 && options.replaceUri === memoryUri;
+  const finalMetadata = isInPlaceUpdate ? { ...options.metadata, supersedes: void 0 } : candidateMetadata;
+  const memory = isInPlaceUpdate ? formatMemoryDocument(options.title, finalMetadata, options.bodyText) : candidateMemory;
+  const writeMode = await memoryWriteMode(ov, config, memoryUri, finalMetadata);
+  if (options.dryRun) {
+    console.log(memory);
+    console.log("\nWould run:");
+    console.log(
+      formatShellCommand(
+        ov,
+        withIdentity(config, [
+          "write",
+          memoryUri,
+          "--from-file",
+          memoryPath,
+          "--mode",
+          writeMode,
+          "--wait",
+          "--timeout",
+          "120"
+        ])
+      )
+    );
+    if (options.replaceUri && !isInPlaceUpdate) {
+      console.log(formatShellCommand(ov, withIdentity(config, ["rm", options.replaceUri])));
+    }
+    return;
+  }
+  await (0, import_promises5.writeFile)(memoryPath, memory, { encoding: "utf8", mode: 384 });
+  await (0, import_promises5.chmod)(memoryPath, 384);
+  await ensureMemoryDirectory(ov, config, memoryDirectoryUri(config, finalMetadata));
+  await writeDurableMemoryFile(ov, config, memoryUri, memoryPath, writeMode);
+  console.log(`Stored memory: ${memoryUri}`);
+  if (options.replaceUri && !isInPlaceUpdate) {
+    const removedReplacedMemory = await removeVikingResourceWithRetry(ov, config, options.replaceUri);
+    if (removedReplacedMemory) {
+      console.log(`Forgot replaced memory: ${options.replaceUri}`);
+    } else {
+      console.error(
+        `Replacement stored, but the superseded memory is still processing. Retry later: threadnote forget ${options.replaceUri}`
+      );
+    }
+  } else if (isInPlaceUpdate) {
+    console.log(`Updated existing memory in place: ${memoryUri}`);
   }
-  const regex = globToRegExp(normalizedPattern);
-  const files = await walkFiles(basePath);
-  return files.filter((filePath) => regex.test(toPosixPath(filePath)));
 }
-function skillResourceUri(skill) {
-  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${uriSegment((0, import_node_path8.basename)((0, import_node_path8.dirname)(skill.filePath)))}-${skill.hash.slice(0, 12)}.md`;
+async function 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 loadIgnorePatterns() {
-  const raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(toolRoot(), ".threadnoteignore"), "utf8");
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+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());
+  }
 }
-function matchesIgnore(relativePath, patterns) {
-  const path = toPosixPath(relativePath);
-  for (const pattern of patterns) {
-    const normalizedPattern = toPosixPath(pattern);
-    if (normalizedPattern.endsWith("/")) {
-      const directory = normalizedPattern.slice(0, -1);
-      if (path === directory || path.includes(`/${directory}/`) || path.startsWith(`${directory}/`)) {
-        return true;
+async function removeVikingResourceWithRetry(ov, config, uri) {
+  const args = withIdentity(config, ["rm", uri]);
+  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());
       }
-      continue;
-    }
-    if (globToRegExp(normalizedPattern).test(path) || globToRegExp(`**/${normalizedPattern}`).test(path)) {
       return true;
     }
+    if (isResourceBusy(result.stderr, result.stdout) && attempt === 3) {
+      return false;
+    }
+    if (!isResourceBusy(result.stderr, result.stdout)) {
+      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
+    }
+    await sleep(1e3 * (attempt + 1));
   }
   return false;
 }
-function shouldRedactPath(relativePath) {
-  const path = toPosixPath(relativePath);
-  return path.endsWith(".mcp.json") || path.endsWith("config.toml") || path.includes("/settings") || path.includes("/settings.local");
+async function vikingResourceExists2(ov, config, uri) {
+  const stat4 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+  return stat4.exitCode === 0;
 }
-function redactContent(relativePath, content) {
-  if (relativePath.endsWith(".json")) {
-    try {
-      const parsed = JSON.parse(content);
-      return `${JSON.stringify(redactJsonValue(parsed), null, 2)}
-`;
-    } catch (_err) {
-      return redactText(content);
+async function ensureDurableMemoryDirectory(ov, config) {
+  await ensureMemoryDirectory(ov, config, durableMemoryDirectoryUri(config));
+}
+async function ensureMemoryDirectory(ov, config, directoryUri) {
+  for (const uri of vikingDirectoryChain(directoryUri)) {
+    const statResult = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+    if (statResult.exitCode === 0) {
+      continue;
     }
+    await maybeRun(
+      false,
+      ov,
+      withIdentity(config, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
+    );
   }
-  return redactText(content);
 }
-function redactJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => redactJsonValue(item));
-  }
-  if (!isJsonObject(value)) {
-    return value;
+function durableMemoryDirectoryUri(config) {
+  return `viking://user/${uriSegment(config.user)}/memories/events`;
+}
+function migratedDurableMemoryUri(config, hash) {
+  return `${durableMemoryDirectoryUri(config)}/threadnote-migrated-${hash.slice(0, 16)}.md`;
+}
+async function hasLegacyLifecycleHandoffCandidates(config) {
+  return (await legacyLifecycleHandoffCandidates(config, 1)).length > 0;
+}
+async function legacyLifecycleHandoffCandidates(config, limit) {
+  const eventsRoot = (0, import_node_path5.join)(localUserMemoriesRoot(config), "events");
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(eventsRoot, { withFileTypes: true });
+  } catch (_err) {
+    return [];
   }
-  const output2 = {};
-  for (const [key, nestedValue] of Object.entries(value)) {
-    output2[key] = isSensitiveKey(key) ? "[REDACTED]" : redactJsonValue(nestedValue);
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const sourcePath = (0, import_node_path5.join)(eventsRoot, entry.name);
+    const original = await readTextIfExists(sourcePath);
+    if (!original || !isClearLegacyHandoffMemory(original) || sensitiveMemoryReason(original)) {
+      continue;
+    }
+    const sourceUri = `${durableMemoryDirectoryUri(config)}/${entry.name}`;
+    candidates.push({
+      metadata: {
+        archivedFrom: sourceUri,
+        kind: "handoff",
+        project: inferLegacyProject(original),
+        sourceAgentClient: "threadnote",
+        status: "archived",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      original,
+      sourceUri
+    });
+    if (limit !== void 0 && candidates.length >= limit) {
+      break;
+    }
   }
-  return output2;
+  return candidates;
 }
-function isSensitiveKey(key) {
-  return /token|secret|password|credential|authorization|api[_-]?key|client[_-]?secret|bearer/i.test(key);
+function lifecycleMigrationUri(config, metadata, hash) {
+  return `${memoryDirectoryUri(config, metadata)}/legacy-${hash.slice(0, 16)}.md`;
 }
-function detectSecretMatches(content) {
-  const detectors = [
-    { label: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    { label: "openai-key", regex: /sk-[A-Za-z0-9_-]{24,}/ },
-    { label: "github-token", regex: /gh[pousr]_[A-Za-z0-9_]{24,}/ },
-    { label: "slack-token", regex: /xox[abprs]-[A-Za-z0-9-]{24,}/ },
-    { label: "bearer-token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{24,}/i },
-    { label: "aws-access-key", regex: /AKIA[0-9A-Z]{16}/ }
+function exactMemoryScopes(config, includeArchived) {
+  const userBase = `viking://user/${uriSegment(config.user)}/memories`;
+  const scopes = [
+    `${userBase}/preferences`,
+    `${userBase}/durable/projects`,
+    `${userBase}/handoffs/active`,
+    `${userBase}/incidents/active`,
+    `${userBase}/events`,
+    `${userBase}/shared`,
+    `viking://agent/${uriSegment(config.agentId)}/memories`,
+    // Seeded project resources (READMEs, AGENTS.md, SKILL.md, docs/**) live
+    // under viking://resources/repos/<project>. Include them so an exact-term
+    // grep in a recall surfaces matches in seeded guidance, not only memories.
+    "viking://resources/repos"
   ];
-  const matches = [];
-  for (const detector of detectors) {
-    if (detector.regex.test(content)) {
-      matches.push(detector.label);
-    }
+  return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
+}
+function memoryUriFor(config, memory, metadata) {
+  const filename = shouldUseStableMemoryUri(metadata) ? `${uriSegment(metadata.topic ?? "current")}.md` : `threadnote-${safeTimestamp()}-${sha256(memory).slice(0, 12)}.md`;
+  return `${memoryDirectoryUri(config, metadata)}/${filename}`;
+}
+function memoryDirectoryUri(config, metadata) {
+  const baseUri = `viking://user/${uriSegment(config.user)}/memories`;
+  const projectSegment = uriSegment(metadata.project ?? "general");
+  switch (metadata.kind) {
+    case "preference":
+      return metadata.status === "active" ? `${baseUri}/preferences` : `${baseUri}/preferences/${uriSegment(metadata.status)}`;
+    case "handoff":
+      return `${baseUri}/handoffs/${uriSegment(metadata.status)}/${projectSegment}`;
+    case "incident":
+      return `${baseUri}/incidents/${uriSegment(metadata.status)}/${projectSegment}`;
+    case "smoke":
+      return `${baseUri}/smoke/${uriSegment(metadata.status)}`;
+    case "durable":
+      return metadata.status === "active" ? `${baseUri}/durable/projects/${projectSegment}` : `${baseUri}/durable/${uriSegment(metadata.status)}/${projectSegment}`;
   }
-  return matches;
 }
-
-// src/share.ts
-var import_promises8 = require("node:fs/promises");
-var import_node_os4 = require("node:os");
-var import_node_path9 = require("node:path");
-var TEAMS_FILE_VERSION = 1;
-var SHARED_SEGMENT = "shared";
-var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
-var DEFAULT_GIT_REMOTE_NAME = "origin";
-var SCRUBBER_PATTERNS = [
-  // Credentials: never redactable. Blocking is the only safe response —
-  // automated redaction risks false negatives that leave material in git.
-  { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-  { name: "API key (sk-...)", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
-  { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
-  { name: "GitHub fine-grained PAT", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}/ },
-  { name: "GitLab PAT", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
-  { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
-  // Matches bare JWTs (three base64url segments). May surface a JWE token in
-  // legitimate docs; if that becomes noisy we can switch to warn-only.
-  { name: "JWT", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
-  { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ },
-  // Slack tokens: xoxa/xoxb/xoxc (configuration)/xoxd (legacy user cookie)/
-  // xoxe (refresh)/xoxp/xoxr/xoxs, with optional -N- segment for the workspace tier.
-  { name: "Slack token", regex: /\bxox[abcdeprs](?:-\d-)?[A-Za-z0-9._-]{10,}/i },
-  // Soft leaks: block by default (so the agent sees them and decides), but
-  // allow opt-in redaction so curated memories with incidental matches can
-  // ship without a manual rewrite. Local home paths are the recurring
-  // real-world leak; the regexes greedily consume the whole path segment
-  // (including subdirectories) up to whitespace or common closing punctuation
-  // so redaction collapses an entire path to a single placeholder rather than
-  // leaving the subpath visible.
-  { name: "macOS home path", placeholder: "<local-path>", regex: /\/Users\/[^\s)>"'`,]+/ },
-  { name: "linux home path", placeholder: "<local-path>", regex: /\b\/home\/[^\s)>"'`,]+/ }
-];
-function applyScrubber(content, { redact }) {
-  let cleaned = content;
-  const redactions = [];
-  for (const pattern of SCRUBBER_PATTERNS) {
-    if (!pattern.regex.test(cleaned)) {
-      continue;
-    }
-    if (!pattern.placeholder || !redact) {
-      return { blocker: pattern.name, cleaned: content, redactions: [] };
-    }
-    const flags = pattern.regex.flags.includes("g") ? pattern.regex.flags : `${pattern.regex.flags}g`;
-    const globalRegex = new RegExp(pattern.regex.source, flags);
-    const matches = cleaned.match(globalRegex) ?? [];
-    cleaned = cleaned.replace(globalRegex, pattern.placeholder);
-    redactions.push({ count: matches.length, name: pattern.name });
-  }
-  return { cleaned, redactions };
+function shouldUseStableMemoryUri(metadata) {
+  return metadata.status === "active" && metadata.topic !== void 0 && metadata.kind !== "smoke";
 }
-async function runShareInit(config, remoteUrl, options) {
-  if (!remoteUrl.trim()) {
-    throw new Error("Provide a git remote URL for the shared memories repo.");
+async function memoryWriteMode(ov, config, memoryUri, metadata) {
+  if (!shouldUseStableMemoryUri(metadata)) {
+    return "create";
   }
-  const dryRun = options.dryRun === true;
-  const teamName = normalizeTeamName(options.team);
-  const teamsFile = await readTeamsFile(config);
-  if (teamsFile.teams[teamName]) {
-    throw new Error(
-      `Team "${teamName}" is already configured (remote ${teamsFile.teams[teamName].remote}). Remove it first with: threadnote share remove --team ${teamName}`
-    );
+  return await vikingResourceExists2(ov, config, memoryUri) ? "replace" : "create";
+}
+function vikingDirectoryChain(directoryUri) {
+  const prefix = "viking://";
+  if (!directoryUri.startsWith(prefix)) {
+    return [directoryUri];
   }
-  const worktree = teamWorktreePath(config, teamName);
-  const gitdir = teamGitdirPath(config, teamName);
-  await assertWorktreeUsable(worktree);
-  if (await exists(gitdir)) {
-    throw new Error(`Gitdir already exists at ${gitdir}; remove it or pick a different team name.`);
+  const parts = directoryUri.slice(prefix.length).split("/").filter(Boolean);
+  const startIndex = parts[0] === "user" && parts.length > 2 ? 3 : 1;
+  const chain = [];
+  for (let index = startIndex; index <= parts.length; index += 1) {
+    chain.push(`${prefix}${parts.slice(0, index).join("/")}`);
   }
-  await ensureDirectory((0, import_node_path9.dirname)(worktree), dryRun);
-  await ensureDirectory((0, import_node_path9.dirname)(gitdir), dryRun);
-  const git = await requiredExecutable("git");
-  await maybeRun(dryRun, git, ["clone", `--separate-git-dir=${gitdir}`, "--", remoteUrl, worktree]);
-  const newConfig = {
-    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    gitdir,
-    name: teamName,
-    remote: remoteUrl,
-    worktree
-  };
-  const updatedTeams = {
-    defaultTeam: shouldSetDefault(options, teamsFile) ? teamName : teamsFile.defaultTeam ?? teamName,
-    teams: { ...teamsFile.teams, [teamName]: newConfig },
-    version: TEAMS_FILE_VERSION
+  return chain;
+}
+function formatMemoryDocument(title, metadata, body) {
+  const header = [
+    title,
+    `kind: ${metadata.kind}`,
+    `status: ${metadata.status}`,
+    metadata.project ? `project: ${metadata.project}` : void 0,
+    metadata.topic ? `topic: ${metadata.topic}` : void 0,
+    `source_agent_client: ${metadata.sourceAgentClient}`,
+    `timestamp: ${metadata.timestamp}`,
+    metadata.supersedes ? `supersedes: ${metadata.supersedes}` : void 0,
+    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0
+  ].filter((line) => line !== void 0);
+  return [...header, "", body.trim()].join("\n");
+}
+function inferMemoryMetadata(memory) {
+  const header = memory.slice(0, Math.max(0, memory.indexOf("\n\n")) || memory.length);
+  const firstLine2 = header.split("\n")[0]?.trim();
+  const kind = parseOptionalMemoryKind(parseHeaderValue(header, "kind")) ?? (firstLine2 === "HANDOFF" ? "handoff" : void 0);
+  const status = parseOptionalMemoryStatus(parseHeaderValue(header, "status"));
+  const project = normalizeOptionalMetadata(parseHeaderValue(header, "project")) ?? normalizeOptionalMetadata(parseHeaderValue(header, "repo"));
+  const topic = normalizeOptionalMetadata(parseHeaderValue(header, "topic")) ?? normalizeOptionalMetadata(parseHeaderValue(header, "task"));
+  return {
+    kind,
+    project,
+    sourceAgentClient: parseHeaderValue(header, "source_agent_client") ?? void 0,
+    status,
+    topic
   };
-  if (dryRun) {
-    console.log(`Would write teams file: ${teamsFilePath(config)}`);
-    console.log(`Would set ${teamName} as default? ${updatedTeams.defaultTeam === teamName}`);
-  } else {
-    await writeTeamsFile(config, updatedTeams);
-    console.log(`Configured shared team "${teamName}" -> ${portablePath(worktree)}`);
+}
+function parseHeaderValue(header, key) {
+  const prefix = `${key}:`;
+  return header.split("\n").find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
+}
+function isClearLegacyHandoffMemory(memory) {
+  if (/^kind:\s*/m.test(memory) || /^status:\s*/m.test(memory)) {
+    return false;
   }
-  if (!dryRun) {
-    await ensureSharedGitignore(worktree, git, options.push !== false);
-    const ingested = await ingestWorktreeFiles(config, newConfig, "create");
-    console.log(`Ingested ${ingested} shared memory file(s) into OpenViking.`);
+  const trimmed = memory.trim();
+  if (trimmed.startsWith("HANDOFF\n")) {
+    return true;
   }
+  if (!trimmed.startsWith("MEMORY\n")) {
+    return false;
+  }
+  return /^(?:#+\s*)?(?:final\s+)?handoff(?:\s+update)?\b/i.test(memoryBody(trimmed));
 }
-var SHARED_GITIGNORE_PATTERNS = ["**/.abstract.md", "**/.overview.md"];
-var SHARED_GITIGNORE_HEADER = "# Threadnote: ignore OpenViking-generated directory summaries.";
-async function ensureSharedGitignore(worktree, git, push) {
-  const gitignorePath = (0, import_node_path9.join)(worktree, ".gitignore");
-  const existing = await readFileIfExists(gitignorePath) ?? "";
-  const lines = existing.split("\n").map((line) => line.trim());
-  const missingPatterns = SHARED_GITIGNORE_PATTERNS.filter((pattern) => !lines.includes(pattern));
-  if (missingPatterns.length === 0) {
-    return;
+function memoryBody(memory) {
+  const separatorIndex = memory.indexOf("\n\n");
+  return separatorIndex === -1 ? "" : memory.slice(separatorIndex + 2).trim();
+}
+function inferLegacyProject(memory) {
+  const explicit = parseHeaderValue(memory, "project") ?? parseHeaderValue(memory, "repo") ?? parseHeaderValue(memory, "repo_path") ?? /\brepo(?:_path)?\s+([~/A-Za-z0-9_.:/-]+)/.exec(memory)?.[1];
+  if (!explicit) {
+    return "general";
   }
-  const hasHeader = lines.includes(SHARED_GITIGNORE_HEADER);
-  const segments = [];
-  if (existing.length > 0 && !existing.endsWith("\n")) {
-    segments.push("\n");
+  const trimmed = explicit.trim().replace(/[`.,;]+$/g, "");
+  return trimmed.includes("/") ? (0, import_node_path5.basename)(trimmed) : trimmed;
+}
+function parseOptionalMemoryKind(value) {
+  if (!value) {
+    return void 0;
   }
-  if (existing.length > 0) {
-    segments.push("\n");
+  try {
+    return parseMemoryKind(value);
+  } catch (_err) {
+    return void 0;
   }
-  if (!hasHeader) {
-    segments.push(SHARED_GITIGNORE_HEADER, "\n");
+}
+function parseOptionalMemoryStatus(value) {
+  if (!value) {
+    return void 0;
   }
-  segments.push(missingPatterns.join("\n"), "\n");
-  await (0, import_promises8.writeFile)(gitignorePath, `${existing}${segments.join("")}`, { encoding: "utf8" });
-  console.log(`Added ${missingPatterns.join(", ")} to ${portablePath(gitignorePath)}`);
-  await maybeRun(false, git, ["-C", worktree, "add", ".gitignore"]);
-  const commitResult = await runCommand(
-    git,
-    ["-C", worktree, "commit", "-m", "share: ignore OpenViking directory summaries"],
-    { allowFailure: true }
-  );
-  if (commitResult.exitCode !== 0) {
-    const detail = commitResult.stderr.trim() || commitResult.stdout.trim();
-    if (!/nothing to commit|no changes added/i.test(detail)) {
-      console.warn(
-        `.gitignore housekeeping commit was rejected (${detail || "unknown"}); it will be retried on the next share sync.`
-      );
-      return;
+  try {
+    return parseMemoryStatus(value);
+  } catch (_err) {
+    return void 0;
+  }
+}
+function normalizeOptionalMetadata(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+async function legacySourceAccounts(config, options) {
+  const explicitAccounts = options.sourceAccount?.filter((account) => account.trim().length > 0) ?? [];
+  if (explicitAccounts.length > 0) {
+    return uniqueStrings(explicitAccounts);
+  }
+  if (options.allAccounts === true) {
+    const accounts = await childDirectoryNames(localVikingDataRoot(config));
+    return accounts.filter((account) => !account.startsWith("_"));
+  }
+  return [config.account];
+}
+async function legacyMemoryCandidates(config, sourceAccounts) {
+  const candidates = [];
+  for (const sourceAccount of sourceAccounts) {
+    const sessionRoot = (0, import_node_path5.join)(localVikingDataRoot(config), sourceAccount, "session");
+    for (const sourceSession of await childDirectoryNames(sessionRoot)) {
+      const historyRoot = (0, import_node_path5.join)(sessionRoot, sourceSession, "history");
+      for (const sourceArchive of await childDirectoryNames(historyRoot)) {
+        if (!sourceArchive.startsWith("archive_")) {
+          continue;
+        }
+        const sourcePath = (0, import_node_path5.join)(historyRoot, sourceArchive, "messages.jsonl");
+        for (const text of await legacyMemoryTexts(sourcePath)) {
+          candidates.push({
+            comparableHash: sha256(comparableMemoryText(text)),
+            hash: sha256(text),
+            sourceAccount,
+            sourceArchive,
+            sourceSession,
+            text
+          });
+        }
+      }
     }
   }
-  if (push) {
-    await maybeRun(false, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+  return candidates.sort((left, right) => legacySourceLabel(left).localeCompare(legacySourceLabel(right)));
+}
+async function legacyMemoryTexts(sourcePath) {
+  const raw = await readTextIfExists(sourcePath);
+  if (!raw) {
+    return [];
+  }
+  const memories = [];
+  for (const line of raw.split("\n")) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmedLine);
+      const text = legacyMessageText(parsed)?.trim();
+      if (text && isLegacyThreadnoteMemory(text)) {
+        memories.push(text);
+      }
+    } catch (_err) {
+      continue;
+    }
   }
+  return memories;
 }
-async function runShareStatus(config, options) {
-  const team = await resolveTeam(config, options.team);
-  const git = await requiredExecutable("git");
-  console.log(`Team: ${team.name}`);
-  console.log(`Remote: ${team.config.remote}`);
-  console.log(`Worktree: ${portablePath(team.config.worktree)}`);
-  console.log(`Gitdir: ${portablePath(team.config.gitdir)}`);
-  await maybeRun(options.dryRun === true, git, ["-C", team.config.worktree, "status", "--short", "--branch"]);
-  await maybeRun(options.dryRun === true, git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME], {
-    allowFailure: true
-  });
-  const ahead = await gitOutput(team.config.worktree, ["rev-list", "--count", "@{u}..HEAD"], options.dryRun === true);
-  const behind = await gitOutput(team.config.worktree, ["rev-list", "--count", "HEAD..@{u}"], options.dryRun === true);
-  if (ahead !== void 0) {
-    console.log(`Ahead of upstream: ${ahead}`);
+function legacyMessageText(value) {
+  if (!isJsonObject(value)) {
+    return void 0;
   }
-  if (behind !== void 0) {
-    console.log(`Behind upstream: ${behind}`);
+  if (typeof value.content === "string") {
+    return value.content;
   }
+  if (!Array.isArray(value.parts)) {
+    return void 0;
+  }
+  const parts = value.parts.map((part) => isJsonObject(part) && part.type === "text" && typeof part.text === "string" ? part.text : void 0).filter((text) => text !== void 0);
+  return parts.length > 0 ? parts.join("\n") : void 0;
 }
-async function runShareSync(config, options) {
-  const team = await resolveTeam(config, options.team);
-  const dryRun = options.dryRun === true;
-  const git = await requiredExecutable("git");
-  const worktree = team.config.worktree;
-  if (!dryRun) {
-    await ensureSharedGitignore(worktree, git, false);
+function isLegacyThreadnoteMemory(text) {
+  return text.startsWith("MEMORY\n") || text.startsWith("HANDOFF\n");
+}
+async function existingDurableMemoryHashes(config) {
+  const hashes = /* @__PURE__ */ new Set();
+  await collectDurableMemoryHashes(localVikingDataRoot(config), hashes);
+  return hashes;
+}
+async function collectDurableMemoryHashes(root, hashes) {
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(root, { withFileTypes: true });
+  } catch (_err) {
+    return;
   }
-  if (await hasUncommittedChanges(worktree)) {
-    if (options.autoCommit === false) {
-      throw new Error(
-        `Worktree ${worktree} has uncommitted changes. Commit them yourself or rerun without --no-auto-commit.`
-      );
+  for (const entry of entries) {
+    const path = (0, import_node_path5.join)(root, entry.name);
+    if (entry.isDirectory()) {
+      await collectDurableMemoryHashes(path, hashes);
+      continue;
+    }
+    if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md") || !isDurableMemoryPath(path)) {
+      continue;
+    }
+    const content = await readTextIfExists(path);
+    if (content) {
+      const trimmedContent = content.trim();
+      hashes.add(sha256(trimmedContent));
+      hashes.add(sha256(comparableMemoryText(trimmedContent)));
     }
-    const message = options.message ?? `share: sync ${(/* @__PURE__ */ new Date()).toISOString()}`;
-    await stageShareableChanges(dryRun, git, worktree);
-    await maybeRun(dryRun, git, ["-C", worktree, "commit", "-m", message], { allowFailure: true });
   }
-  const beforeRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
-  await maybeRun(dryRun, git, ["-C", worktree, "fetch", DEFAULT_GIT_REMOTE_NAME]);
-  const pullResult = dryRun ? void 0 : await runCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
-  if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "pull", "--rebase", DEFAULT_GIT_REMOTE_NAME])}`);
-  } else if (pullResult && pullResult.exitCode !== 0) {
-    if (await exists((0, import_node_path9.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path9.join)(team.config.gitdir, "rebase-apply"))) {
-      throw new Error(
-        `git pull --rebase reported conflicts in ${worktree}. The worktree is in a rebase-in-progress state.
-Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then re-run \`threadnote share sync\`.`
-      );
+}
+function isDurableMemoryPath(path) {
+  return path.split(import_node_path5.sep).includes("memories");
+}
+async function childDirectoryNames(path) {
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(path, { withFileTypes: true });
+  } catch (_err) {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+async function readTextIfExists(path) {
+  try {
+    const pathStat = await (0, import_promises5.stat)(path);
+    if (!pathStat.isFile()) {
+      return void 0;
     }
-    throw new Error(
-      `git pull --rebase failed in ${worktree}: ${pullResult.stderr.trim() || pullResult.stdout.trim() || "unknown error"}`
-    );
+    return await (0, import_promises5.readFile)(path, "utf8");
+  } catch (_err) {
+    return void 0;
   }
-  const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
-  if (!dryRun && beforeRev && afterRev && beforeRev !== afterRev) {
-    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
-    await applyChangesToOpenViking(config, team.config, changes);
-    console.log(`Reindexed ${changes.length} file change(s) into OpenViking.`);
-  } else if (!dryRun) {
-    console.log("No upstream changes to reindex.");
+}
+function sensitiveMemoryReason(text) {
+  const patterns = [
+    { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+    { name: "API key", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
+    { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
+    { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
+    { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ }
+  ];
+  return patterns.find((pattern) => pattern.regex.test(text))?.name;
+}
+function comparableMemoryText(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("MEMORY\n")) {
+    return trimmed;
   }
-  if (options.push !== false) {
-    await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
+  const separatorIndex = trimmed.indexOf("\n\n");
+  return separatorIndex === -1 ? trimmed : trimmed.slice(separatorIndex + 2).trim();
+}
+function legacySourceLabel(candidate) {
+  return `${candidate.sourceAccount}/${candidate.sourceSession}/${candidate.sourceArchive}`;
+}
+function localVikingDataRoot(config) {
+  return (0, import_node_path5.join)(config.agentContextHome, "data", "viking");
+}
+function localUserMemoriesRoot(config) {
+  return (0, import_node_path5.join)(localVikingDataRoot(config), config.account, "user", uriSegment(config.user), "memories");
+}
+function uniqueStrings(values) {
+  return [...new Set(values)].sort();
+}
+function isResourceBusy(stderr, stdout) {
+  const output2 = `${stderr}
+${stdout}`.toLowerCase();
+  return output2.includes("resource is busy") || output2.includes("resource is being processed");
+}
+async function buildHandoff(options) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]) ?? getInvocationCwd();
+  const branch = await gitValue(["branch", "--show-current"], repoRoot) ?? "unknown";
+  const status = await gitValue(["status", "--short"], repoRoot) ?? "";
+  const diffStat = await gitValue(["diff", "--stat", "HEAD"], repoRoot) ?? "";
+  const touchedFiles = await gitTouchedFiles(repoRoot);
+  const repoName = (0, import_node_path5.basename)(repoRoot);
+  const metadata = {
+    kind: "handoff",
+    project: normalizeOptionalMetadata(options.project) ?? repoName,
+    sourceAgentClient: options.sourceAgentClient ?? "codex",
+    status: "active",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    topic: normalizeOptionalMetadata(options.topic)
+  };
+  const bodyText = [
+    `repo: ${repoName}`,
+    `repo_path: ${repoRoot}`,
+    `branch: ${branch || "unknown"}`,
+    `task: ${options.task ?? "unspecified"}`,
+    "",
+    "files_touched:",
+    formatBlock(touchedFiles, "- none"),
+    "",
+    "git_status:",
+    formatBlock(status, "- clean"),
+    "",
+    "diff_stat:",
+    formatBlock(diffStat, "- none"),
+    "",
+    "tests:",
+    options.tests ?? "- not recorded",
+    "",
+    "blockers:",
+    options.blockers ?? "- none recorded",
+    "",
+    "next_step:",
+    options.nextStep ?? "- inspect the current repo state and continue from this handoff"
+  ].join("\n");
+  return { bodyText, metadata };
+}
+async function gitTouchedFiles(cwd) {
+  const changedFiles = await gitValue(["diff", "--name-only", "HEAD"], cwd);
+  const untrackedFiles = await gitValue(["ls-files", "--others", "--exclude-standard"], cwd);
+  const files = /* @__PURE__ */ new Set();
+  for (const value of [changedFiles, untrackedFiles]) {
+    for (const line of (value ?? "").split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed) {
+        files.add(trimmed);
+      }
+    }
   }
+  return [...files].sort().join("\n");
 }
-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 });
+function formatBlock(value, emptyValue) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return emptyValue;
+  }
+  return trimmed.split("\n").map((line) => `- ${line}`).join("\n");
 }
-async function runSharePublish(config, sourceUri, options) {
-  assertVikingUri(sourceUri);
-  const team = await resolveTeam(config, options.team);
-  const dryRun = options.dryRun === true;
-  const preview = options.preview === true;
-  if (isInSharedNamespace(config, sourceUri)) {
-    throw new Error(`Memory ${sourceUri} is already in the shared namespace.`);
+
+// src/update-check.ts
+var import_node_child_process2 = require("node:child_process");
+var import_promises6 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NPM_LATEST_URL = "https://registry.npmjs.org/threadnote/latest";
+var FETCH_TIMEOUT_MS = 3e3;
+async function checkForThreadnoteUpdate(args) {
+  if (args.currentVersion === "unknown") {
+    return void 0;
   }
-  const ov = await openVikingCliForMode(dryRun);
-  const rawContent = await readMemoryContent(config, ov, sourceUri, dryRun);
-  const stripped = stripPersonalProvenance(rawContent);
-  const scrub = applyScrubber(stripped, { redact: options.redact === true });
-  const targetUri = sharedUriFor(config, sourceUri, team.name);
-  if (preview) {
-    console.log(`PREVIEW source: ${sourceUri}`);
-    console.log(`PREVIEW destination: ${targetUri}`);
-    if (scrub.blocker) {
-      console.log(
-        `PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or rerun with --redact for soft-leak patterns.`
-      );
+  const cached = await readUpdateCache(args.cachePath);
+  if (cached && isCacheFresh(cached)) {
+    return compareVersions(args.currentVersion, cached.latestVersion);
+  }
+  const fresh = await fetchLatestVersion();
+  if (fresh) {
+    await writeUpdateCache(args.cachePath, {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      latestVersion: fresh,
+      version: 1
+    });
+    return compareVersions(args.currentVersion, fresh);
+  }
+  if (cached) {
+    return compareVersions(args.currentVersion, cached.latestVersion);
+  }
+  return void 0;
+}
+function spawnDetachedAutoUpdate() {
+  try {
+    const entry = process.argv[1];
+    if (typeof entry !== "string" || entry.length === 0) {
       return;
     }
-    for (const redaction of scrub.redactions) {
-      console.log(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
-    }
-    console.log("-----BEGIN PREVIEW-----");
-    console.log(scrub.cleaned);
-    console.log("-----END PREVIEW-----");
-    return;
+    const child = (0, import_node_child_process2.spawn)(process.execPath, [entry, "update", "--yes"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {
   }
-  if (scrub.blocker) {
-    throw new Error(
-      `Refusing to publish ${sourceUri}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
-    );
+}
+function compareVersions(currentVersion, latestVersion) {
+  return {
+    currentVersion,
+    latestVersion,
+    outdated: isNewerVersion(latestVersion, currentVersion)
+  };
+}
+function isNewerVersion(candidate, baseline) {
+  const candidateParts = parseVersion(candidate);
+  const baselineParts = parseVersion(baseline);
+  for (let index = 0; index < 3; index += 1) {
+    if (candidateParts[index] !== baselineParts[index]) {
+      return candidateParts[index] > baselineParts[index];
+    }
   }
-  for (const redaction of scrub.redactions) {
-    console.log(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
+  return false;
+}
+function parseVersion(value) {
+  const parts = value.split(".").map((part) => parseInt(part, 10));
+  return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+}
+function isCacheFresh(cache) {
+  const checkedAt = new Date(cache.checkedAt).getTime();
+  return Number.isFinite(checkedAt) && Date.now() - checkedAt < CACHE_TTL_MS;
+}
+async function readUpdateCache(cachePath) {
+  try {
+    const raw = await (0, import_promises6.readFile)(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
+      return void 0;
+    }
+    return { checkedAt: parsed.checkedAt, latestVersion: parsed.latestVersion, version: 1 };
+  } catch {
+    return void 0;
   }
-  const content = scrub.cleaned;
-  if (!dryRun && await vikingResourceExists2(ov, config, targetUri)) {
-    throw new Error(
-      `Refusing to publish: ${targetUri} already exists in the shared namespace. Inspect it via threadnote read; if it should be replaced, forget the existing shared copy first.`
-    );
+}
+async function writeUpdateCache(cachePath, contents) {
+  try {
+    await (0, import_promises6.mkdir)((0, import_node_path6.dirname)(cachePath), { recursive: true });
+    await (0, import_promises6.writeFile)(cachePath, `${JSON.stringify(contents)}
+`, { encoding: "utf8", mode: 384 });
+  } catch {
   }
-  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`
-      );
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(NPM_LATEST_URL, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return void 0;
     }
+    const data = await response.json();
+    return typeof data.version === "string" && data.version.length > 0 ? data.version : void 0;
+  } catch {
+    return void 0;
   }
-  console.log(`Published ${sourceUri} -> ${targetUri}`);
 }
-async function runShareUnpublish(config, sourceUri, options) {
-  assertVikingUri(sourceUri);
-  const team = await resolveTeam(config, options.team);
-  const dryRun = options.dryRun === true;
-  if (!isInTeamNamespace(config, sourceUri, team.name)) {
-    throw new Error(`Memory ${sourceUri} is not in team "${team.name}" shared namespace.`);
-  }
-  const ov = await openVikingCliForMode(dryRun);
-  const content = await readMemoryContent(config, ov, sourceUri, dryRun);
-  const targetUri = personalUriFor(config, sourceUri, team.name);
-  if (!dryRun && await vikingResourceExists2(ov, config, targetUri)) {
-    throw new Error(
-      `Refusing to unpublish: a personal memory already exists at ${targetUri}. Move or forget it first, then retry.`
-    );
+
+// src/version.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path7 = require("node:path");
+var cachedVersion;
+function getThreadnoteVersion() {
+  if (cachedVersion !== void 0) {
+    return cachedVersion;
   }
-  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 });
+  try {
+    const packageJsonPath = (0, import_node_path7.join)(__dirname, "..", "package.json");
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf8"));
+    cachedVersion = typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown";
+  } catch {
+    cachedVersion = "unknown";
   }
-  console.log(`Unpublished ${sourceUri} -> ${targetUri}`);
+  return cachedVersion;
 }
-async function runShareList(config, _options) {
-  const teams = await readTeamsFile(config);
-  const entries = Object.values(teams.teams);
-  if (entries.length === 0) {
-    console.log("No shared teams configured. Run: threadnote share init <remote-url>");
-    return;
+
+// src/hooks.ts
+var MANAGED_HOOKS = [
+  {
+    event: "PreCompact",
+    command: HOOK_PRE_COMPACT_COMMAND,
+    description: "Auto-store a handoff snapshot before context compaction so the next turn can recall it."
+  },
+  {
+    event: "SessionStart",
+    command: HOOK_SESSION_START_COMMAND,
+    description: "Pre-load the latest handoff for the current repo into the new session context."
   }
-  for (const team of entries) {
-    const marker = team.name === teams.defaultTeam ? " (default)" : "";
-    console.log(`- ${team.name}${marker}`);
-    console.log(`    remote: ${team.remote}`);
-    console.log(`    worktree: ${portablePath(team.worktree)}`);
-    console.log(`    gitdir: ${portablePath(team.gitdir)}`);
-    console.log(`    added: ${team.addedAt}`);
+];
+async function runHooksInstall(config, agent, options) {
+  const apply = options.apply === true && options.dryRun !== true;
+  const remove = options.remove === true;
+  switch (agent) {
+    case "claude":
+      await runClaudeHooksInstall({ apply, remove });
+      return;
+    case "codex":
+      printCodexHooksNotice(remove);
+      return;
+    case "cursor":
+      printNoHooksSupported("cursor", remove);
+      return;
+    case "copilot":
+      printNoHooksSupported("copilot", remove);
+      return;
   }
 }
-async function runShareRemove(config, options) {
-  const team = await resolveTeam(config, options.team);
-  const dryRun = options.dryRun === true;
-  const teamsFile = await readTeamsFile(config);
-  const remaining = {};
-  for (const [name, value] of Object.entries(teamsFile.teams)) {
-    if (name !== team.name) {
-      remaining[name] = value;
-    }
+async function runClaudeHooksInstall(options) {
+  const path = expandPath(CLAUDE_SETTINGS_PATH);
+  const existingRaw = await exists(path) ? await (0, import_promises7.readFile)(path, "utf8") : "{}";
+  const parsed = parseJsonConfigObject(existingRaw) ?? {};
+  const next = options.remove ? withoutThreadnoteHooks(parsed) : withThreadnoteHooks(parsed);
+  const before = JSON.stringify(parsed);
+  const after = JSON.stringify(next);
+  if (before === after) {
+    console.log(`Claude hooks already ${options.remove ? "absent" : "managed"} in ${path}.`);
+    return;
   }
-  const remainingNames = Object.keys(remaining);
-  const nextDefault = teamsFile.defaultTeam === team.name ? remainingNames[0] : teamsFile.defaultTeam;
-  const updated = { defaultTeam: nextDefault, teams: remaining, version: TEAMS_FILE_VERSION };
-  if (dryRun) {
-    console.log(`Would update teams file: ${teamsFilePath(config)}`);
-  } else {
-    await writeTeamsFile(config, updated);
-    console.log(`Removed team "${team.name}" from teams.json.`);
+  console.log(`${options.apply ? "Updating" : "Would update"} ${path}:`);
+  for (const entry of MANAGED_HOOKS) {
+    console.log(`  ${options.remove ? "-" : "+"} ${entry.event}: ${entry.command}`);
   }
-  if (options.keepFiles !== true) {
-    await removePath(team.config.worktree, "shared worktree", dryRun);
-    await removePath(team.config.gitdir, "shared gitdir", dryRun);
-  } else {
-    console.log(`Keeping files at ${portablePath(team.config.worktree)} and ${portablePath(team.config.gitdir)}`);
+  if (!options.apply) {
+    console.log("\nRe-run with --apply to actually modify the file.");
+    return;
   }
+  await (0, import_promises7.mkdir)((0, import_node_path8.dirname)(path), { recursive: true });
+  const serialized = `${JSON.stringify(next, void 0, 2)}
+`;
+  await (0, import_promises7.writeFile)(path, serialized, { encoding: "utf8", mode: 384 });
+  await (0, import_promises7.chmod)(path, 384);
+  console.log(`${options.remove ? "Removed" : "Installed"} threadnote-managed Claude hooks.`);
 }
-function normalizeTeamName(input2) {
-  const candidate = (input2 ?? "default").trim();
-  if (!candidate) {
-    return "default";
+function withThreadnoteHooks(input2) {
+  const hooks = ensureMutableObject(input2.hooks);
+  for (const entry of MANAGED_HOOKS) {
+    const list = ensureMutableArray(hooks[entry.event]).filter((item) => !isManagedThreadnoteEntry(item));
+    list.push({
+      [THREADNOTE_HOOK_MARKER]: THREADNOTE_HOOK_MARKER_VALUE,
+      matcher: "",
+      hooks: [{ type: "command", command: entry.command }]
+    });
+    hooks[entry.event] = list;
   }
-  if (!/^[a-z0-9][a-z0-9._-]*$/.test(candidate) || /^\.+$/.test(candidate)) {
-    throw new Error(
-      `Invalid team name "${input2}". Team names must start with a lowercase letter or digit and contain only [a-z0-9._-]. Single-dot or dot-only names are rejected so they don't collapse to the shared-root or parent directory.`
-    );
+  return { ...input2, hooks };
+}
+function withoutThreadnoteHooks(input2) {
+  if (!isJsonObject(input2.hooks)) {
+    return input2;
+  }
+  const hooks = {};
+  for (const [event, value] of Object.entries(input2.hooks)) {
+    if (!Array.isArray(value)) {
+      hooks[event] = value;
+      continue;
+    }
+    const filtered = value.filter((item) => !isManagedThreadnoteEntry(item));
+    if (filtered.length > 0) {
+      hooks[event] = filtered;
+    }
   }
-  return candidate;
+  if (Object.keys(hooks).length === 0) {
+    const next = { ...input2 };
+    delete next.hooks;
+    return next;
+  }
+  return { ...input2, hooks };
 }
-function teamsFilePath(config) {
-  return (0, import_node_path9.join)(config.agentContextHome, "share", "teams.json");
+function isManagedThreadnoteEntry(value) {
+  return isJsonObject(value) && value[THREADNOTE_HOOK_MARKER] === THREADNOTE_HOOK_MARKER_VALUE;
 }
-function teamWorktreePath(config, team) {
-  return (0, import_node_path9.join)(
-    config.agentContextHome,
-    "data",
-    "viking",
-    config.account,
-    "user",
-    uriSegment(config.user),
-    "memories",
-    SHARED_SEGMENT,
-    team
+function ensureMutableObject(value) {
+  return isJsonObject(value) ? { ...value } : {};
+}
+function ensureMutableArray(value) {
+  return Array.isArray(value) ? [...value] : [];
+}
+function printCodexHooksNotice(remove) {
+  if (remove) {
+    console.log("Codex CLI does not expose a managed hook surface today, so there is nothing to remove.");
+    return;
+  }
+  console.log(
+    [
+      "Codex CLI does not currently expose lifecycle hooks (no PreCompact or SessionStart analog).",
+      "Threadnote already installs Codex user instructions at ~/.codex/AGENTS.md; that remains the active guidance surface.",
+      "If a future Codex release adds hook events, threadnote will pick them up via `install-hooks codex`."
+    ].join("\n")
   );
 }
-function teamGitdirPath(config, team) {
-  return (0, import_node_path9.join)(config.agentContextHome, "share", "teams", `${team}.gitdir`);
+function printNoHooksSupported(agent, remove) {
+  if (remove) {
+    console.log(`${agent} does not expose a hook surface; nothing to remove.`);
+    return;
+  }
+  console.log(
+    [
+      `${agent} does not expose agent-mode hooks today.`,
+      "Threadnote already installs user-level instructions for this agent; that remains the active guidance surface.",
+      "Hooks support will be added if the agent gains a hook surface upstream."
+    ].join("\n")
+  );
 }
-async function readTeamsFile(config) {
-  const path = teamsFilePath(config);
-  const raw = await readFileIfExists(path);
-  if (!raw) {
-    return { teams: {}, version: TEAMS_FILE_VERSION };
+async function hasManagedClaudeHooks() {
+  const path = expandPath(CLAUDE_SETTINGS_PATH);
+  if (!await exists(path)) {
+    return false;
   }
+  const raw = await (0, import_promises7.readFile)(path, "utf8");
   const parsed = parseJsonConfigObject(raw);
-  if (!parsed) {
-    throw new Error(`Could not parse teams file ${path}`);
-  }
-  if (typeof parsed.version === "number" && parsed.version > TEAMS_FILE_VERSION) {
-    throw new Error(
-      `Teams file ${path} was written with version ${parsed.version}; this Threadnote binary understands up to version ${TEAMS_FILE_VERSION}. Upgrade Threadnote (\`threadnote update\`) before continuing.`
-    );
+  if (!parsed || !isJsonObject(parsed.hooks)) {
+    return false;
   }
-  const teams = {};
-  if (typeof parsed.teams === "object" && parsed.teams !== null && !Array.isArray(parsed.teams)) {
-    for (const [name, value] of Object.entries(parsed.teams)) {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        console.warn(`Skipping non-object team entry "${name}" in ${path}.`);
-        continue;
-      }
-      const entry = value;
-      if (typeof entry.remote !== "string" || entry.remote.length === 0) {
-        console.warn(`Skipping team entry "${name}" in ${path}: missing or empty "remote" field.`);
-        continue;
-      }
-      teams[name] = {
-        addedAt: typeof entry.addedAt === "string" ? entry.addedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
-        gitdir: typeof entry.gitdir === "string" ? entry.gitdir : teamGitdirPath(config, name),
-        name,
-        remote: entry.remote,
-        worktree: typeof entry.worktree === "string" ? entry.worktree : teamWorktreePath(config, name)
-      };
+  for (const value of Object.values(parsed.hooks)) {
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    if (value.some((item) => isManagedThreadnoteEntry(item))) {
+      return true;
     }
   }
-  const defaultTeam = typeof parsed.defaultTeam === "string" ? parsed.defaultTeam : void 0;
-  return { defaultTeam, teams, version: TEAMS_FILE_VERSION };
-}
-async function writeTeamsFile(config, contents) {
-  const path = teamsFilePath(config);
-  await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(path), { recursive: true });
-  const serializable = {
-    defaultTeam: contents.defaultTeam,
-    teams: contents.teams,
-    version: contents.version
-  };
-  await (0, import_promises8.writeFile)(path, `${JSON.stringify(serializable, void 0, 2)}
-`, { encoding: "utf8", mode: 384 });
-}
-async function resolveTeam(config, requested) {
-  const teamsFile = await readTeamsFile(config);
-  const entries = Object.entries(teamsFile.teams);
-  if (entries.length === 0) {
-    throw new Error("No shared teams configured. Run: threadnote share init <remote-url>");
-  }
-  const wantName = requested ? normalizeTeamName(requested) : teamsFile.defaultTeam ?? entries[0][0];
-  const found = teamsFile.teams[wantName];
-  if (!found) {
-    const known = entries.map(([name]) => name).join(", ");
-    throw new Error(`Team "${wantName}" is not configured. Known teams: ${known}`);
-  }
-  return { config: found, name: wantName };
+  return false;
 }
-function shouldSetDefault(options, existing) {
-  if (options.setDefault === true) {
-    return true;
+async function runPreCompactHook(config, options = {}) {
+  try {
+    const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
+    const project = repoRoot ? (0, import_node_path8.basename)(repoRoot) : "general";
+    await runHandoff(config, {
+      blockers: "- none recorded",
+      dryRun: options.dryRun === true,
+      nextStep: "Continue from this auto-snapshot. A manual `threadnote handoff` will produce a richer write-up if you have more context.",
+      project,
+      sourceAgentClient: "claude",
+      task: "Auto-snapshot captured at Claude PreCompact (deterministic safety net before context compaction).",
+      tests: "- not recorded (auto-snapshot)",
+      topic: HOOK_AUTO_PRECOMPACT_TOPIC
+    });
+  } catch (err) {
+    process.stderr.write(
+      `threadnote pre-compact-hook: snapshot skipped (${err instanceof Error ? err.message : String(err)})
+`
+    );
   }
-  return existing.defaultTeam === void 0;
 }
-async function assertWorktreeUsable(worktree) {
-  if (!await exists(worktree)) {
-    return;
-  }
-  if (!await isDirectory(worktree)) {
-    throw new Error(`Cannot use ${worktree} as a worktree: not a directory.`);
-  }
-  const entries = await (0, import_promises8.readdir)(worktree);
-  if (entries.length > 0) {
-    const preview = entries.slice(0, 5).join(", ");
-    const suffix = entries.length > 5 ? `, +${entries.length - 5} more` : "";
-    throw new Error(
-      `Worktree ${worktree} is not empty (contains: ${preview}${suffix}). Move or remove its contents, then retry threadnote share init.`
+async function runSessionStartHook(config, options = {}) {
+  try {
+    const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
+    if (!repoRoot) {
+      return;
+    }
+    const project = (0, import_node_path8.basename)(repoRoot);
+    await emitUpdateBannerIfOutdated(config);
+    process.stdout.write(`## Threadnote \u2014 latest context for ${project}
+
+`);
+    await runRecall(config, {
+      dryRun: options.dryRun === true,
+      inferScope: true,
+      nodeLimit: "5",
+      query: `${project} latest handoff durable feature memory`
+    });
+  } catch (err) {
+    process.stderr.write(
+      `threadnote session-start-hook: recall skipped (${err instanceof Error ? err.message : String(err)})
+`
     );
   }
 }
-async function ingestWorktreeFiles(config, team, initialMode) {
-  const ov = await openVikingCliForMode(false);
-  const files = await walkMemoryFiles(team.worktree);
-  for (const file of files) {
-    const uri = workfileToVikingUri(config, team, file);
-    await ensureSharedDirectoryChain(config, ov, uri, false);
-    await ingestSingleFile(ov, config, uri, file, initialMode);
+async function emitUpdateBannerIfOutdated(config) {
+  try {
+    const result = await checkForThreadnoteUpdate({
+      cachePath: (0, import_node_path8.join)(config.agentContextHome, ".update-state.json"),
+      currentVersion: getThreadnoteVersion()
+    });
+    if (!result || !result.outdated) {
+      return;
+    }
+    if (process.env.THREADNOTE_AUTO_UPDATE === "1") {
+      process.stdout.write(
+        `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Auto-updating in the background; the new version takes effect next session.
+
+`
+      );
+      spawnDetachedAutoUpdate();
+      return;
+    }
+    process.stdout.write(
+      `[threadnote] v${result.latestVersion} available (current v${result.currentVersion}). Run: threadnote update
+
+`
+    );
+  } catch {
   }
-  return files.length;
 }
-async function walkMemoryFiles(root) {
-  const out = [];
-  async function visit(path, depth) {
-    let entries;
-    try {
-      entries = await (0, import_promises8.readdir)(path, { withFileTypes: true });
-    } catch (err) {
-      console.warn(`Skipping ${path} during shared-tree walk: ${err instanceof Error ? err.message : String(err)}`);
-      return;
+
+// src/seeding.ts
+var import_promises8 = require("node:fs/promises");
+var import_node_path9 = require("node:path");
+async function runSeed(config, options) {
+  const manifest = await readSeedManifest(config.manifestPath);
+  const ignorePatterns = await loadIgnorePatterns();
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const statePath = (0, import_node_path9.join)(config.agentContextHome, SEED_STATE_FILE);
+  const state = options.force === true ? { files: {}, version: 1 } : await readSeedState(statePath);
+  const projects = filterProjects(manifest.projects, options.only);
+  let importedCount = 0;
+  let skippedCount = 0;
+  let unchangedCount = 0;
+  for (const project of projects) {
+    const projectRoot = expandPath(project.path);
+    if (!await exists(projectRoot)) {
+      console.log(`WARN project missing: ${project.name} (${projectRoot})`);
+      continue;
     }
-    for (const entry of entries) {
-      if (entry.name === ".git") {
-        continue;
-      }
-      const full = (0, import_node_path9.join)(path, entry.name);
-      if (entry.isDirectory()) {
-        if (depth === 0 && !SHAREABLE_MEMORY_KIND_DIRS.includes(entry.name)) {
-          continue;
-        }
-        await visit(full, depth + 1);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      if (depth === 0) {
+    const candidates = await collectSeedCandidates(project, projectRoot, ignorePatterns);
+    for (const candidate of candidates) {
+      const fileStat = await statSeedFile(candidate.filePath);
+      const recorded = state.files[candidate.destinationUri];
+      if (fileStat && recorded && recorded.mtimeMs === fileStat.mtimeMs && recorded.size === fileStat.size) {
+        unchangedCount += 1;
         continue;
       }
-      if (!entry.name.endsWith(".md")) {
+      const importPath = await prepareSeedFile(config, candidate, options.dryRun === true);
+      if (!importPath) {
+        skippedCount += 1;
         continue;
       }
-      out.push(full);
+      const args = withIdentity(config, ["add-resource", importPath, "--to", candidate.destinationUri, "--wait"]);
+      await maybeRun(options.dryRun === true, ov, args);
+      importedCount += 1;
+      if (fileStat && options.dryRun !== true) {
+        state.files[candidate.destinationUri] = { mtimeMs: fileStat.mtimeMs, size: fileStat.size };
+      }
     }
   }
-  await visit(root, 0);
-  return out;
-}
-function workfileToVikingUri(config, team, filePath) {
-  const rel = (0, import_node_path9.relative)(team.worktree, filePath).split(import_node_path9.sep).join("/");
-  return `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
-}
-function isInSharedNamespace(config, uri) {
-  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`);
-}
-function isInTeamNamespace(config, uri, team) {
-  return uri.startsWith(`viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`);
-}
-function sharedUriFor(config, personalUri, team) {
-  const prefix = `viking://user/${uriSegment(config.user)}/memories/`;
-  if (!personalUri.startsWith(prefix)) {
-    throw new Error(`Refusing to publish memory outside the current user namespace: ${personalUri}`);
+  if (options.dryRun !== true) {
+    await writeSeedState(statePath, state);
   }
-  const rest = personalUri.slice(prefix.length);
-  return `${prefix}${SHARED_SEGMENT}/${team}/${rest}`;
+  console.log(
+    `Seed complete: ${importedCount} candidate(s), ${unchangedCount} unchanged, ${skippedCount} skipped for safety.`
+  );
 }
-function personalUriFor(config, sharedUri, team) {
-  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`;
-  if (!sharedUri.startsWith(prefix)) {
-    throw new Error(`Refusing to unpublish a URI outside team "${team}" shared namespace: ${sharedUri}`);
+function filterProjects(projects, only) {
+  if (!only || only.length === 0) {
+    return projects;
   }
-  const rest = sharedUri.slice(prefix.length);
-  return `viking://user/${uriSegment(config.user)}/memories/${rest}`;
+  const known = new Set(projects.map((project) => project.name));
+  const missing = only.filter((name) => !known.has(name));
+  if (missing.length > 0) {
+    const all = [...known].join(", ");
+    throw new Error(`Unknown project(s) in --only: ${missing.join(", ")}. Manifest projects: ${all}`);
+  }
+  const want = new Set(only);
+  return projects.filter((project) => want.has(project.name));
 }
-function vikingUriToWorktreeRelative(config, uri, team) {
-  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/${team}/`;
-  if (!uri.startsWith(prefix)) {
-    throw new Error(`URI ${uri} is not inside team "${team}" shared subtree.`);
+async function statSeedFile(path) {
+  try {
+    const result = await (0, import_promises8.stat)(path);
+    return { mtimeMs: result.mtimeMs, size: result.size };
+  } catch (_err) {
+    return void 0;
   }
-  return uri.slice(prefix.length);
 }
-function stripPersonalProvenance(content) {
-  const lines = content.split("\n");
-  let headerEnd = lines.length;
-  for (let index = 0; index < lines.length; index += 1) {
-    if (lines[index].trim() === "") {
-      headerEnd = index;
-      break;
+async function readSeedState(path) {
+  try {
+    const raw = await (0, import_promises8.readFile)(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !isJsonObject(parsed.files)) {
+      return { files: {}, version: 1 };
     }
-  }
-  const cleaned = [];
-  for (let index = 0; index < headerEnd; index += 1) {
-    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
-      continue;
+    const files = {};
+    for (const [uri, entry] of Object.entries(parsed.files)) {
+      if (isJsonObject(entry) && typeof entry.mtimeMs === "number" && typeof entry.size === "number") {
+        files[uri] = { mtimeMs: entry.mtimeMs, size: entry.size };
+      }
     }
-    cleaned.push(lines[index]);
-  }
-  for (let index = headerEnd; index < lines.length; index += 1) {
-    cleaned.push(lines[index]);
+    return { files, version: 1 };
+  } catch (_err) {
+    return { files: {}, version: 1 };
   }
-  return cleaned.join("\n");
 }
-async function readMemoryContent(config, ov, uri, dryRun) {
-  const args = withIdentity(config, ["read", uri]);
-  if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(ov, args)}`);
-    return "<dry-run memory body>";
-  }
-  const result = await runCommand(ov, args);
-  if (!result.stdout.trim()) {
-    throw new Error(`Refusing to publish empty memory at ${uri}`);
-  }
-  return result.stdout;
+async function writeSeedState(path, state) {
+  await ensureDirectory((0, import_node_path9.dirname)(path), false);
+  await (0, import_promises8.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
 }
-async function ensureSharedDirectoryChain(config, ov, memoryUri, dryRun) {
-  const directoryUri = parentUri(memoryUri);
-  for (const uri of sharedDirectoryChain(config, directoryUri)) {
-    const args = withIdentity(config, ["stat", uri]);
-    if (dryRun) {
-      console.log(`Would run: ${formatShellCommand(ov, args)}`);
-      continue;
-    }
-    const statResult = await runCommand(ov, args, { allowFailure: true });
-    if (statResult.exitCode === 0) {
+async function runInitManifest(config, options) {
+  const manifestPath = expandPath(
+    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path9.join)(config.agentContextHome, USER_MANIFEST_NAME)
+  );
+  const repoInputs = options.repo && options.repo.length > 0 ? options.repo : [getInvocationCwd()];
+  const existingManifest = options.replace === true || !await exists(manifestPath) ? void 0 : await readSeedManifest(manifestPath);
+  const existingProjects = existingManifest?.projects ?? [];
+  const projects = [...existingProjects];
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of existingProjects) {
+    seen.add(await projectIdentity(project.path));
+  }
+  for (const repoInput of repoInputs) {
+    const repoRoot = await resolveRepoRoot(repoInput);
+    const identity = await projectIdentity(repoRoot);
+    if (seen.has(identity)) {
+      console.log(`Already in manifest: ${repoRoot}`);
       continue;
     }
-    await maybeRun(false, ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+    seen.add(identity);
+    projects.push(projectManifestForRepo(repoRoot, projects));
   }
-}
-function parentUri(uri) {
-  const lastSlash = uri.lastIndexOf("/");
-  return lastSlash === -1 ? uri : uri.slice(0, lastSlash);
-}
-function sharedDirectoryChain(config, directoryUri) {
-  const prefix = `viking://user/${uriSegment(config.user)}/memories/${SHARED_SEGMENT}/`;
-  if (!directoryUri.startsWith(prefix)) {
-    return [directoryUri];
+  const outputManifest = {
+    version: 1,
+    projects: projects.map((project) => ({
+      name: project.name,
+      path: project.path,
+      uri: project.uri,
+      seed: [...project.seed]
+    }))
+  };
+  if (existingManifest?.futureMonorepo) {
+    const futureMonorepoKey = "future_monorepo";
+    const pathCandidatesKey = "path_candidates";
+    outputManifest[futureMonorepoKey] = {
+      [pathCandidatesKey]: [...existingManifest.futureMonorepo.pathCandidates],
+      uri: existingManifest.futureMonorepo.uri
+    };
   }
-  const parts = directoryUri.slice(prefix.length).split("/").filter(Boolean);
-  const chain = [];
-  for (let index = 1; index <= parts.length; index += 1) {
-    chain.push(`${prefix}${parts.slice(0, index).join("/")}`);
+  const output2 = jsYaml.dump(outputManifest, { lineWidth: 120, noRefs: true });
+  if (options.dryRun === true) {
+    console.log(`# Would write ${manifestPath}`);
+    console.log(output2.trimEnd());
+    return;
   }
-  return chain;
+  await ensureDirectory((0, import_node_path9.dirname)(manifestPath), false);
+  await (0, import_promises8.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises8.chmod)(manifestPath, 384);
+  console.log(`Wrote manifest: ${manifestPath}`);
+  console.log("Seed with:");
+  console.log("  threadnote seed --dry-run");
+  console.log("  threadnote seed");
 }
-async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun) {
-  if (dryRun) {
-    const args = withIdentity(config, [
-      "write",
-      uri,
-      "--from-file",
-      "<staged temp file>",
-      "--mode",
-      initialMode,
-      "--wait",
-      "--timeout",
-      "120"
-    ]);
-    console.log(`Would run: ${formatShellCommand(ov, args)}`);
-    return;
+async function runSeedSkills(config, options) {
+  const ov = await openVikingCliForMode(options.dryRun === true);
+  const skills = await collectSkillCandidates(config);
+  const nativeMode = options.native === true;
+  console.log(
+    nativeMode ? "Skill seed mode: native OpenViking skills. This requires a working VLM config." : "Skill seed mode: resource catalog. Use --native only after configuring a working VLM provider."
+  );
+  for (const skill of skills) {
+    console.log(`Skill ${skill.source}: ${skill.filePath}`);
+    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : ["add-resource", skill.filePath, "--to", skillResourceUri(skill), "--wait"];
+    await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  }
+  console.log(`Skill seed complete: ${skills.length} unique skill(s).`);
+}
+async function resolveRepoRoot(repoInput) {
+  const inputPath = expandPath(repoInput);
+  if (!await isDirectory(inputPath)) {
+    throw new Error(`Repo path is not a directory: ${inputPath}`);
   }
-  const stagingDir = await (0, import_promises8.mkdtemp)((0, import_node_path9.join)((0, import_node_os4.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path9.join)(stagingDir, "body.txt");
+  return await gitValue(["rev-parse", "--show-toplevel"], inputPath) ?? inputPath;
+}
+async function projectIdentity(path) {
+  const expanded = expandPath(path);
   try {
-    await (0, import_promises8.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
-    await writeOvFileWithRetry(config, ov, uri, tempPath, initialMode);
-  } finally {
-    await (0, import_promises8.rm)(stagingDir, { force: true, recursive: true });
+    return await (0, import_promises8.realpath)(expanded);
+  } catch (_err) {
+    return expanded;
   }
 }
-async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode) {
-  const maxAttempts = 4;
-  const existedBeforeWrite = await vikingResourceExists2(ov, config, uri);
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists2(ov, config, uri);
-    const ourWriteLanded = existsNow && !existedBeforeWrite;
-    const mode = attempt === 0 ? initialMode : ourWriteLanded ? "replace" : initialMode;
-    const args = withIdentity(config, [
-      "write",
-      uri,
-      "--from-file",
-      fromFile,
-      "--mode",
-      mode,
-      "--wait",
-      "--timeout",
-      "120"
-    ]);
-    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 (isTransientOvFailure(result.stderr, result.stdout) && await vikingResourceExists2(ov, config, uri) && !existedBeforeWrite) {
-      console.log("OpenViking accepted the write but returned an error before the wait completed; draining the queue.");
-      await waitForOvQueue(ov, config);
-      return;
-    }
-    if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
-      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
+function projectManifestForRepo(repoRoot, existingProjects) {
+  const baseName = uriSegment((0, import_node_path9.basename)(repoRoot));
+  const usedNames = new Set(existingProjects.map((project) => project.name));
+  const usedUris = new Set(existingProjects.map((project) => project.uri));
+  let name = baseName;
+  let uri = `viking://resources/repos/${name}`;
+  if (usedNames.has(name) || usedUris.has(uri)) {
+    name = `${baseName}-${sha256(repoRoot).slice(0, 8)}`;
+    uri = `viking://resources/repos/${name}`;
+  }
+  return {
+    name,
+    path: portablePath(repoRoot),
+    seed: DEFAULT_SEED_PATTERNS,
+    uri
+  };
+}
+async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of project.seed) {
+    const files = await resolveProjectPattern(projectRoot, pattern);
+    for (const filePath of files) {
+      const relativePath = toPosixPath((0, import_node_path9.relative)(projectRoot, filePath));
+      if (seen.has(relativePath) || matchesIgnore(relativePath, ignorePatterns)) {
+        continue;
+      }
+      seen.add(relativePath);
+      candidates.push({
+        destinationUri: `${trimTrailingSlash(project.uri)}/${relativePath}`,
+        filePath,
+        projectName: project.name,
+        relativePath
+      });
     }
-    await sleep(1e3 * (attempt + 1));
   }
+  return candidates;
 }
-async function waitForOvQueue(ov, config) {
-  const result = await runCommand(ov, withIdentity(config, ["wait", "--timeout", "120"]), { allowFailure: true });
-  if (result.stdout.trim()) {
-    console.log(result.stdout.trim());
+async function resolveProjectPattern(projectRoot, pattern) {
+  const normalizedPattern = toPosixPath(pattern);
+  if (!hasGlob(normalizedPattern)) {
+    const filePath = (0, import_node_path9.join)(projectRoot, normalizedPattern);
+    return await isFile(filePath) ? [filePath] : [];
   }
-  if (result.stderr.trim()) {
-    console.error(result.stderr.trim());
+  const globBase = getGlobBase(normalizedPattern);
+  const basePath = (0, import_node_path9.join)(projectRoot, globBase);
+  if (!await exists(basePath)) {
+    return [];
   }
+  const regex = globToRegExp(normalizedPattern);
+  const files = await walkFiles(basePath);
+  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path9.relative)(projectRoot, filePath))));
 }
-function isTransientOvFailure(stderr, stdout) {
-  const output2 = `${stderr}
-${stdout}`.toLowerCase();
-  return output2.includes("resource is busy") || output2.includes("resource is being processed") || output2.includes("network error") || output2.includes("error sending request") || output2.includes("http request failed") || output2.includes("connection refused") || output2.includes("connection reset") || output2.includes("timed out");
-}
-async function ingestSingleFile(ov, config, uri, filePath, initialMode) {
-  const content = await (0, import_promises8.readFile)(filePath, "utf8");
-  await writeMemoryFile(config, ov, uri, content, initialMode, false);
-}
-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.`
+async function prepareSeedFile(config, candidate, dryRun) {
+  const content = await (0, import_promises8.readFile)(candidate.filePath, "utf8");
+  const redactedContent = shouldRedactPath(candidate.relativePath) ? redactContent(candidate.relativePath, content) : content;
+  const secretMatches = detectSecretMatches(redactedContent);
+  if (secretMatches.length > 0) {
+    console.log(
+      `SKIP ${candidate.projectName}/${candidate.relativePath}: possible secret (${secretMatches.slice(0, MAX_SECRET_MATCHES_TO_PRINT).join(", ")})`
     );
-    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;
+    return void 0;
   }
-  const parts = rollbackUri.slice(prefix.length).split("/");
-  const sharedIndex = parts.indexOf("shared");
-  if (sharedIndex === -1 || sharedIndex + 2 >= parts.length) {
-    return;
+  if (redactedContent === content) {
+    return candidate.filePath;
   }
-  const relative3 = parts.slice(sharedIndex + 2).join("/");
-  if (!relative3) {
-    return;
+  const redactedPath = (0, import_node_path9.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
+  if (dryRun) {
+    console.log(`Would write redacted copy: ${redactedPath}`);
+    return redactedPath;
   }
-  await (0, import_promises8.rm)((0, import_node_path9.join)(worktree, relative3), { force: true });
+  await ensureDirectory((0, import_node_path9.dirname)(redactedPath), false);
+  await (0, import_promises8.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
+  await (0, import_promises8.chmod)(redactedPath, 384);
+  return redactedPath;
 }
-async function removeMemoryUri(config, ov, uri, dryRun) {
-  const args = withIdentity(config, ["rm", uri]);
-  if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(ov, args)}`);
-    return;
+async function collectSkillCandidates(config) {
+  const sources = [
+    { pattern: "~/.codex/skills/**/SKILL.md", source: "codex-global" },
+    { pattern: "~/.codex/plugins/cache/**/skills/**/SKILL.md", source: "codex-plugin-cache" },
+    { pattern: "~/.claude/skills/**/SKILL.md", source: "claude-global" }
+  ];
+  try {
+    const manifest = await readSeedManifest(config.manifestPath);
+    for (const project of manifest.projects) {
+      sources.push({
+        pattern: `${project.path}/.claude/skills/**/SKILL.md`,
+        source: `repo-local:${project.name}`
+      });
+    }
+  } catch (err) {
+    console.log(`WARN cannot read manifest for repo-local skill discovery: ${errorMessage(err)}`);
   }
-  const maxAttempts = 4;
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const result = await runCommand(ov, args, { allowFailure: true });
-    if (result.exitCode === 0) {
-      if (result.stdout.trim()) {
-        console.log(result.stdout.trim());
+  const seenHashes = /* @__PURE__ */ new Set();
+  const skills = [];
+  for (const source of sources) {
+    const files = await resolveAbsolutePattern(expandPath(source.pattern));
+    for (const filePath of files) {
+      const content = await (0, import_promises8.readFile)(filePath, "utf8");
+      const matches = detectSecretMatches(content);
+      if (matches.length > 0) {
+        console.log(`SKIP skill with possible secret: ${filePath}`);
+        continue;
       }
-      return;
-    }
-    if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
-      throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
+      const hash = sha256(content);
+      if (seenHashes.has(hash)) {
+        continue;
+      }
+      seenHashes.add(hash);
+      skills.push({ filePath, hash, source: source.source });
     }
-    await sleep(1e3 * (attempt + 1));
   }
+  return skills;
 }
-async function vikingResourceExists2(ov, config, uri) {
-  const result = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-  return result.exitCode === 0;
-}
-async function hasUncommittedChanges(worktree) {
-  const result = await runCommand("git", ["-C", worktree, "status", "--porcelain"], { allowFailure: true });
-  return result.stdout.trim().length > 0;
-}
-async function gitOutput(worktree, args, dryRun) {
-  if (dryRun) {
-    return void 0;
-  }
-  const result = await runCommand("git", ["-C", worktree, ...args], { allowFailure: true });
-  if (result.exitCode !== 0) {
-    return void 0;
+async function resolveAbsolutePattern(pattern) {
+  const normalizedPattern = toPosixPath(pattern);
+  if (!hasGlob(normalizedPattern)) {
+    return await isFile(normalizedPattern) ? [normalizedPattern] : [];
   }
-  return result.stdout.trim();
-}
-async function listChangedFiles(worktree, beforeRev, afterRev) {
-  const result = await runCommand("git", ["-C", worktree, "diff", "--name-status", "-z", `${beforeRev}..${afterRev}`], {
-    allowFailure: true
-  });
-  if (result.exitCode !== 0) {
+  const globBase = getGlobBase(normalizedPattern);
+  const basePath = globBase.startsWith("/") ? globBase : `/${globBase}`;
+  if (!await exists(basePath)) {
     return [];
   }
-  const entries = result.stdout.split("\0").filter((part) => part.length > 0);
-  const changes = [];
-  for (let index = 0; index < entries.length; ) {
-    const raw = entries[index];
-    const head = raw.slice(0, 1);
-    if (head === "R" || head === "C") {
-      const oldRel = entries[index + 1];
-      const newRel = entries[index + 2];
-      if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path9.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path9.join)(worktree, newRel), relativePath: newRel, status: "added" });
+  const regex = globToRegExp(normalizedPattern);
+  const files = await walkFiles(basePath);
+  return files.filter((filePath) => regex.test(toPosixPath(filePath)));
+}
+function skillResourceUri(skill) {
+  return `viking://resources/agent-skills/${uriSegment(skill.source)}/${uriSegment((0, import_node_path9.basename)((0, import_node_path9.dirname)(skill.filePath)))}-${skill.hash.slice(0, 12)}.md`;
+}
+async function loadIgnorePatterns() {
+  const raw = await (0, import_promises8.readFile)((0, import_node_path9.join)(toolRoot(), ".threadnoteignore"), "utf8");
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function matchesIgnore(relativePath, patterns) {
+  const path = toPosixPath(relativePath);
+  for (const pattern of patterns) {
+    const normalizedPattern = toPosixPath(pattern);
+    if (normalizedPattern.endsWith("/")) {
+      const directory = normalizedPattern.slice(0, -1);
+      if (path === directory || path.includes(`/${directory}/`) || path.startsWith(`${directory}/`)) {
+        return true;
       }
-      index += 3;
       continue;
     }
-    const rel = entries[index + 1];
-    if (rel) {
-      const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path9.join)(worktree, rel), relativePath: rel, status });
+    if (globToRegExp(normalizedPattern).test(path) || globToRegExp(`**/${normalizedPattern}`).test(path)) {
+      return true;
     }
-    index += 2;
   }
-  return changes;
+  return false;
 }
-async function applyChangesToOpenViking(config, team, changes) {
-  const ov = await openVikingCliForMode(false);
-  for (const change of changes) {
-    if (!change.relativePath.endsWith(".md")) {
-      continue;
-    }
-    const firstSegment = change.relativePath.split("/")[0];
-    if (!SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment)) {
-      continue;
-    }
-    const uri = workfileToVikingUri(config, team, change.path);
-    if (change.status === "removed") {
-      await removeMemoryUri(config, ov, uri, false);
-      continue;
-    }
-    if (!await isFile(change.path)) {
-      continue;
+function shouldRedactPath(relativePath) {
+  const path = toPosixPath(relativePath);
+  return path.endsWith(".mcp.json") || path.endsWith("config.toml") || path.includes("/settings") || path.includes("/settings.local");
+}
+function redactContent(relativePath, content) {
+  if (relativePath.endsWith(".json")) {
+    try {
+      const parsed = JSON.parse(content);
+      return `${JSON.stringify(redactJsonValue(parsed), null, 2)}
+`;
+    } catch (_err) {
+      return redactText(content);
     }
-    const ovHasResource = await vikingResourceExists2(ov, config, uri);
-    if (ovHasResource) {
-      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
-      console.warn(`share sync: ${uri}: ${reason}.`);
+  }
+  return redactText(content);
+}
+function redactJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactJsonValue(item));
+  }
+  if (!isJsonObject(value)) {
+    return value;
+  }
+  const output2 = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    output2[key] = isSensitiveKey(key) ? "[REDACTED]" : redactJsonValue(nestedValue);
+  }
+  return output2;
+}
+function isSensitiveKey(key) {
+  return /token|secret|password|credential|authorization|api[_-]?key|client[_-]?secret|bearer/i.test(key);
+}
+function detectSecretMatches(content) {
+  const detectors = [
+    { label: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+    { label: "openai-key", regex: /sk-[A-Za-z0-9_-]{24,}/ },
+    { label: "github-token", regex: /gh[pousr]_[A-Za-z0-9_]{24,}/ },
+    { label: "slack-token", regex: /xox[abprs]-[A-Za-z0-9-]{24,}/ },
+    { label: "bearer-token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{24,}/i },
+    { label: "aws-access-key", regex: /AKIA[0-9A-Z]{16}/ }
+  ];
+  const matches = [];
+  for (const detector of detectors) {
+    if (detector.regex.test(content)) {
+      matches.push(detector.label);
     }
-    await ensureSharedDirectoryChain(config, ov, uri, false);
-    const writeMode = ovHasResource ? "replace" : "create";
-    await ingestSingleFile(ov, config, uri, change.path, writeMode);
   }
+  return matches;
 }
 
 // src/lifecycle.ts