threadnote 1.1.6 → 1.3.0

package/dist/mcp_server.cjs

@@ -36193,6 +36193,7 @@ function grepUrisFromJson(output) {
   }
 }
 var RECALL_CATEGORY_ORDER = ["memories", "resources", "skills"];
+var RECALL_PROMOTED_EXACT_SCORE = 0;
 function recallSnippet(value) {
   if (typeof value !== "string") {
     return "";
@@ -36244,11 +36245,14 @@ function parseRecallHits(output, options = {}) {
     return [];
   }
 }
+function stripAnchor(uri) {
+  return uri.replace(/#.*$/, "");
+}
 function mergeRecallHits(passes) {
   const byDocument = /* @__PURE__ */ new Map();
   for (const pass of passes) {
     for (const hit of pass) {
-      const documentUri = hit.uri.replace(/#.*$/, "");
+      const documentUri = stripAnchor(hit.uri);
       const existing = byDocument.get(documentUri);
       if (!existing || hit.score > existing.score) {
         byDocument.set(documentUri, { ...hit, uri: documentUri });
@@ -36256,23 +36260,120 @@ function mergeRecallHits(passes) {
     }
   }
   return [...byDocument.values()].sort(
-    (left, right) => RECALL_CATEGORY_ORDER.indexOf(left.category) - RECALL_CATEGORY_ORDER.indexOf(right.category) || right.score - left.score
+    (left, right) => recallCategoryRank(left.category) - recallCategoryRank(right.category) || right.score - left.score
+  );
+}
+function recallCategoryRank(category) {
+  const index = RECALL_CATEGORY_ORDER.indexOf(category);
+  return index === -1 ? RECALL_CATEGORY_ORDER.length : index;
+}
+function dedupeByContent(hits) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const hit of hits) {
+    if (hit.category !== "memories" && hit.snippet.length > 0) {
+      const key = `${hit.category}
+${hit.snippet}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+    }
+    kept.push(hit);
+  }
+  return kept;
+}
+function categoryForUri(uri) {
+  if (uri.includes("/memories/")) {
+    return "memories";
+  }
+  if (uri.startsWith("viking://resources/agent-skills/")) {
+    return "skills";
+  }
+  return "resources";
+}
+function contextTypeForCategory(category) {
+  if (category === "memories") {
+    return "memory";
+  }
+  return category === "skills" ? "skill" : "resource";
+}
+function applyExactMatchBoost(hits, exactMatches) {
+  if (exactMatches.length === 0) {
+    return hits;
+  }
+  const termsByUri = new Map(exactMatches.map((match) => [stripAnchor(match.uri), match.terms]));
+  const annotated = hits.map((hit) => {
+    const terms = termsByUri.get(stripAnchor(hit.uri));
+    return terms ? { ...hit, exactTerms: terms } : hit;
+  });
+  const present = new Set(annotated.map((hit) => stripAnchor(hit.uri)));
+  const promoted = [...termsByUri.keys()].filter((uri) => !present.has(uri)).map((uri) => {
+    const category = categoryForUri(uri);
+    return {
+      category,
+      contextType: contextTypeForCategory(category),
+      exactTerms: termsByUri.get(uri) ?? [],
+      score: RECALL_PROMOTED_EXACT_SCORE,
+      snippet: "",
+      uri
+    };
+  });
+  return [...annotated, ...promoted].sort(
+    (left, right) => recallCategoryRank(left.category) - recallCategoryRank(right.category) || (right.exactTerms?.length ?? 0) - (left.exactTerms?.length ?? 0) || right.score - left.score
   );
 }
-function formatRecallHits(hits, maxHits) {
-  if (hits.length === 0) {
+function renderRecallHits(shown, overflow) {
+  if (shown.length === 0) {
     return void 0;
   }
-  const shown = hits.slice(0, maxHits);
   const lines = shown.flatMap((hit, index) => {
-    const head = `${index + 1}. ${hit.contextType} \xB7 score ${hit.score.toFixed(2)} \xB7 ${hit.uri}`;
+    const scorePart = hit.score > 0 ? `score ${hit.score.toFixed(2)}` : void 0;
+    const exactPart = hit.exactTerms?.length ? `exact: ${hit.exactTerms.join(", ")}` : void 0;
+    const head = `${index + 1}. ${[hit.contextType, scorePart, exactPart].filter(Boolean).join(" \xB7 ")} \xB7 ${hit.uri}`;
     return hit.snippet ? [head, `   ${hit.snippet}`] : [head];
   });
-  if (hits.length > maxHits) {
-    lines.push(`(+${hits.length - maxHits} more \u2014 refine the query or read a URI above)`);
+  if (overflow > 0) {
+    lines.push(`(+${overflow} more \u2014 refine the query or read a URI above)`);
   }
   return lines.join("\n");
 }
+var RECALL_CATEGORY_RESERVE = 2;
+function selectShownHits(ranked, limit, reserve) {
+  if (ranked.length <= limit) {
+    return ranked;
+  }
+  const selected = /* @__PURE__ */ new Set();
+  for (const category of RECALL_CATEGORY_ORDER) {
+    let taken = 0;
+    for (const hit of ranked) {
+      if (selected.size >= limit || taken >= reserve) {
+        break;
+      }
+      if (hit.category === category && !selected.has(hit.uri)) {
+        selected.add(hit.uri);
+        taken += 1;
+      }
+    }
+  }
+  for (const hit of ranked) {
+    if (selected.size >= limit) {
+      break;
+    }
+    selected.add(hit.uri);
+  }
+  return ranked.filter((hit) => selected.has(hit.uri));
+}
+function buildRecallSections(passes, exactMatches, limit) {
+  const ranked = dedupeByContent(applyExactMatchBoost(mergeRecallHits(passes), exactMatches));
+  const shown = selectShownHits(ranked, limit, RECALL_CATEGORY_RESERVE);
+  const shownUris = new Set(shown.map((hit) => stripAnchor(hit.uri)));
+  return {
+    exactTail: formatExactMatchPointers(exactMatches.filter((match) => !shownUris.has(stripAnchor(match.uri)))),
+    ranked,
+    semanticSection: renderRecallHits(shown, ranked.length - shown.length)
+  };
+}
 function exactMemoryScopeUris(params) {
   const { agentMemoriesUri, includeArchived, intents, projectName, projectResourceUri, userBase } = params;
   const durable = projectName ? `${userBase}/durable/projects/${projectName}` : `${userBase}/durable/projects`;
@@ -36719,835 +36820,1126 @@ function indexRepairWarning(uri, result) {
   return `${uri}: ${result.stderr.trim() || result.stdout.trim() || "reindex failed"}`;
 }
 
-// src/memory_hygiene.ts
+// src/share.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_os2 = require("node:os");
 var import_node_path3 = require("node:path");
-var HYGIENE_SOURCES_HEADING = "## Threadnote Hygiene Sources";
-var STALE_HANDOFF_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
-function parseMemoryDocument(uri, content) {
-  const trimmed = content.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  const separatorIndex = trimmed.indexOf("\n\n");
-  const header = separatorIndex === -1 ? trimmed : trimmed.slice(0, separatorIndex);
-  const body = separatorIndex === -1 ? "" : trimmed.slice(separatorIndex + 2).trim();
-  const firstLine = header.split("\n")[0]?.trim();
-  if (firstLine !== "MEMORY" && firstLine !== "HANDOFF") {
-    return void 0;
-  }
-  const kind = parseOptionalMemoryKind(headerValue(header, "kind")) ?? (firstLine === "HANDOFF" ? "handoff" : void 0);
-  const status = parseOptionalMemoryStatus(headerValue(header, "status")) ?? "active";
-  if (!kind) {
-    return void 0;
+var import_node_util = require("node:util");
+var TEAMS_FILE_VERSION = 1;
+var SHARED_SEGMENT = "shared";
+var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
+var SHAREABLE_ARTIFACT_DIR = "agent-artifacts";
+var SHAREABLE_TOP_LEVEL_DIRS = [...SHAREABLE_MEMORY_KIND_DIRS, SHAREABLE_ARTIFACT_DIR];
+var ARTIFACT_INSTALL_METADATA_VERSION = 1;
+var BUNDLE_MANIFEST_VERSION = 1;
+var BUNDLE_MANIFEST_FILE = ".threadnote-bundle.json";
+var BUNDLE_INSTALL_METADATA_FILE = ".threadnote-bundle-install.json";
+var OV_SUMMARY_FILES = [".abstract.md", ".overview.md"];
+var BUNDLE_IGNORE_DIR_NAMES = [".git", "node_modules", "reviews", "repos"];
+var PACK_INDEX_SUFFIX = ".pack.md";
+var PACK_MANIFEST_SUFFIX = ".pack.json";
+var PACK_FILES_DIR = "files";
+var PACK_ROOT_TOKEN = "${THREADNOTE_PACK_ROOT}";
+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)>"'`,]+/ },
+  // No leading \b: it only matches when a word char precedes the slash, which
+  // misses the common cases (after =, :, whitespace, or line start). Mirror the
+  // macOS pattern so /home/... is caught in every position.
+  { name: "linux home path", placeholder: "<local-path>", regex: /\/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 {
-    body,
-    content: trimmed,
-    headerTitle: firstLine,
-    metadata: {
-      archivedFrom: headerValue(header, "archived_from"),
-      kind,
-      project: normalizeOptionalMetadata(headerValue(header, "project") ?? headerValue(header, "repo")),
-      sourceAgentClient: headerValue(header, "source_agent_client") ?? "unknown",
-      status,
-      supersedes: headerValue(header, "supersedes"),
-      timestamp: headerValue(header, "timestamp") ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-      topic: normalizeOptionalMetadata(headerValue(header, "topic"))
-    },
-    uri
-  };
+  return { cleaned, redactions };
 }
-function buildCompactPlan(records, options) {
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const groupedRecords = records.map((record2) => groupableRecord(record2)).filter((item) => item !== void 0).filter((item) => item.project === options.project).filter((item) => options.topic === void 0 || item.topic === options.topic).filter((item) => options.kind === void 0 || item.record.metadata.kind === options.kind);
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of groupedRecords) {
-    groups.set(item.groupKey, [...groups.get(item.groupKey) ?? [], item]);
+var autoShareStates = /* @__PURE__ */ new Map();
+function startShareBackgroundFetch(config2) {
+  const state = autoShareState(config2);
+  if (state.timer) {
+    return;
   }
-  const keepUpdates = [];
-  const archives = [];
-  const forgets = [];
-  const manualReview = [];
-  for (const group of [...groups.values()].sort(compareGroupedRecordLists)) {
-    const recordsInGroup = group.map((item) => item.record);
-    const kind = recordsInGroup[0]?.metadata.kind;
-    const topic = group[0]?.topic;
-    const project = group[0]?.project;
-    if (!kind || !project || !isCompactableKind(kind)) {
-      continue;
+  void refreshShareUpdateState(config2, { force: true }).catch((err) => {
+    console.error(`share auto-fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  state.timer = setInterval(() => {
+    void refreshShareUpdateState(config2, { force: false }).catch((err) => {
+      console.error(`share auto-fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }, AUTO_SHARE_FETCH_INTERVAL_MS);
+  state.timer.unref?.();
+}
+async function syncSharedReposBeforeAgentRead(config2) {
+  const state = autoShareState(config2);
+  return enqueueShareOperation(state, async () => {
+    await loadPendingReindexes(config2, state);
+    const warnings = await refreshShareUpdateStateLocked(config2, state, { force: false });
+    const syncTeams = /* @__PURE__ */ new Set([...state.behindTeams, ...state.pendingReindexes.keys()]);
+    if (syncTeams.size === 0) {
+      return { syncedTeams: [], warnings };
     }
-    const duplicateGroups = groupBy(recordsInGroup, (record2) => comparableMemoryBody(record2.body));
-    const duplicateForgetUris = /* @__PURE__ */ new Set();
-    const distinctBodyCount = duplicateGroups.size;
-    for (const duplicateGroup of duplicateGroups.values()) {
-      if (duplicateGroup.length < 2) {
-        continue;
-      }
-      const duplicateKeep = preferredKeepRecord(duplicateGroup, topic);
-      for (const duplicate of sortedNewestFirst(duplicateGroup).filter((record2) => record2.uri !== duplicateKeep.uri)) {
-        duplicateForgetUris.add(duplicate.uri);
-        forgets.push({ reason: `exact duplicate of ${duplicateKeep.uri}`, uri: duplicate.uri });
-      }
-      if (distinctBodyCount === 1 || kind !== "handoff") {
-        keepUpdates.push({
-          content: memoryContentWithHygieneSources(
-            duplicateKeep,
-            duplicateGroup.map((record2) => record2.uri)
-          ),
-          reason: "keep exact duplicate group with source URIs",
-          sourceUris: duplicateGroup.map((record2) => record2.uri),
-          uri: duplicateKeep.uri
-        });
+    const syncedTeams = [];
+    const remainingBehind = new Set(state.behindTeams);
+    for (const team of syncTeams) {
+      try {
+        const warning2 = await runShareSyncQuiet(config2, state, { team });
+        if (warning2) {
+          warnings.push(warning2);
+        } 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)}`
+        );
       }
     }
-    const remainingRecords = recordsInGroup.filter((record2) => !duplicateForgetUris.has(record2.uri));
-    if (recordsInGroup.length > 1 && distinctBodyCount === 1) {
-      continue;
-    }
-    if (remainingRecords.length === 0) {
+    state.behindTeams = remainingBehind;
+    state.lastCheckedAt = Date.now();
+    return { syncedTeams, warnings };
+  });
+}
+function autoShareState(config2) {
+  const key = `${config2.agentContextHome}:${config2.account}:${config2.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(config2) {
+  return (0, import_node_path3.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+}
+async function loadPendingReindexes(config2, state) {
+  const raw = await readFileIfExists(pendingReindexesPath(config2));
+  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;
     }
-    if (remainingRecords.length === 1) {
-      const [record2] = remainingRecords;
-      if (!record2) {
+    const changes = [];
+    for (const item of value) {
+      if (typeof item !== "object" || item === null || Array.isArray(item)) {
         continue;
       }
-      if (record2.metadata.supersedes === record2.uri) {
-        keepUpdates.push({
-          content: memoryContentWithHygieneSources(record2, [record2.uri]),
-          reason: "strip self-supersedes header",
-          sourceUris: [record2.uri],
-          uri: record2.uri
-        });
-      }
-      if (isStaleLookingHandoff(record2, now)) {
-        manualReview.push({ reason: "stale-looking active handoff", uri: record2.uri });
+      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 });
       }
-      continue;
     }
-    if (kind === "handoff") {
-      const keep = preferredKeepRecord(remainingRecords, topic);
-      const sourceUris = recordsInGroup.map((record2) => record2.uri);
-      keepUpdates.push({
-        content: memoryContentWithHygieneSources(keep, sourceUris),
-        reason: "keep latest handoff and preserve source URIs",
-        sourceUris,
-        uri: keep.uri
-      });
-      for (const record2 of sortedNewestFirst(remainingRecords).filter((item) => item.uri !== keep.uri)) {
-        archives.push({
-          kind,
-          project,
-          reason: `older handoff for ${project}/${topic ?? "unknown"}`,
-          topic,
-          uri: record2.uri
-        });
-      }
-      continue;
-    }
-    for (const record2 of sortedNewestFirst(remainingRecords)) {
-      manualReview.push({ reason: `non-exact ${kind} memory in overlapping group`, uri: record2.uri });
+    if (changes.length > 0) {
+      pending.set(team, changes);
     }
   }
-  return {
-    archives: dedupeByUri(archives),
-    forgets: dedupeByUri(forgets),
-    keepUpdates: dedupeByUri(keepUpdates),
-    manualReview: dedupeByUri(manualReview),
-    options,
-    recordsScanned: groupedRecords.length
-  };
+  state.pendingReindexes = pending;
 }
-function memoryContentWithHygieneSources(record2, sourceUris) {
-  const body = stripHygieneSources(record2.body);
-  const uniqueSourceUris = [...new Set(sourceUris)].sort();
-  const metadata = {
-    ...record2.metadata,
-    supersedes: record2.metadata.supersedes === record2.uri ? void 0 : record2.metadata.supersedes
+async function writePendingReindexes(config2, state) {
+  const path = pendingReindexesPath(config2);
+  if (state.pendingReindexes.size === 0) {
+    await (0, import_promises4.rm)(path, { force: true });
+    return;
+  }
+  const contents = {
+    teams: Object.fromEntries(state.pendingReindexes),
+    version: 1
   };
-  return formatMemoryDocument(
-    record2.headerTitle,
-    metadata,
-    [body, "", HYGIENE_SOURCES_HEADING, "", ...uniqueSourceUris.map((uri) => `- ${uri}`)].join("\n")
-  );
+  await (0, import_promises4.mkdir)((0, import_node_path3.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);
 }
-function formatCompactPlan(plan, options) {
-  const scope = [
-    `project ${plan.options.project}`,
-    plan.options.topic ? `topic ${plan.options.topic}` : void 0,
-    plan.options.kind ? `kind ${plan.options.kind}` : void 0
-  ].filter((item) => item !== void 0).join(", ");
-  const lines = [
-    `${options.apply ? "Applying" : "Dry-run"} memory hygiene plan for ${scope}`,
-    `Records scanned: ${plan.recordsScanned}`,
-    "",
-    formatPlanSection(
-      "Keep/update",
-      plan.keepUpdates.map((action) => `${action.uri} (${action.reason}; sources: ${action.sourceUris.length})`)
-    ),
-    formatPlanSection(
-      "Archive old handoffs",
-      plan.archives.map((action) => `${action.uri} (${action.reason})`)
-    ),
-    formatPlanSection(
-      "Forget exact duplicates",
-      plan.forgets.map((action) => `${action.uri} (${action.reason})`)
-    ),
-    formatPlanSection(
-      "Manual review",
-      plan.manualReview.map((item) => `${item.uri} (${item.reason})`)
-    )
-  ];
-  if (!options.apply) {
-    lines.push("", "No changes made. Re-run with --apply to execute this plan.");
+async function refreshShareUpdateState(config2, options) {
+  const state = autoShareState(config2);
+  const warnings = await enqueueShareOperation(
+    state,
+    async () => refreshShareUpdateStateLocked(config2, state, options)
+  );
+  for (const warning2 of warnings) {
+    console.error(warning2);
   }
-  return lines.join("\n");
 }
-function recallHygieneNudges(text, options) {
-  const activeUris = activePersonalMemoryUrisFromText(text, options.user);
-  const nudges = [];
-  const returnedUriSet = new Set(activeUris);
-  const returnedRecords = options.records?.filter((record2) => returnedUriSet.has(record2.uri)).map((record2) => groupableRecord(record2)) ?? [];
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of returnedRecords) {
-    if (!item) {
-      continue;
-    }
-    groups.set(item.groupKey, [...groups.get(item.groupKey) ?? [], item]);
+async function refreshShareUpdateStateLocked(config2, state, options) {
+  const now = Date.now();
+  if (!options.force && state.lastCheckedAt > 0 && now - state.lastCheckedAt < AUTO_SHARE_FETCH_INTERVAL_MS) {
+    return [];
   }
-  for (const group of [...groups.values()].sort(compareGroupedRecordLists)) {
-    if (group.length < 3) {
-      continue;
-    }
-    const first = group[0];
-    if (!first || !isCompactableKind(first.record.metadata.kind)) {
-      continue;
-    }
-    const topic = first.topic;
-    if (!topic) {
-      continue;
+  try {
+    const statuses = await fetchShareUpdateStatuses(config2);
+    const nextBehindTeams = new Set(state.behindTeams);
+    for (const status of statuses) {
+      if (status.warning) {
+        continue;
+      }
+      if (status.behind > 0) {
+        nextBehindTeams.add(status.team);
+      } else {
+        nextBehindTeams.delete(status.team);
+      }
     }
-    nudges.push(
-      `${group.length} active ${memoryKindPlural(first.record.metadata.kind)} look overlapping for ${first.project}/${topic}; run compact_context({"project":"${first.project}","topic":"${topic}","dryRun":true}).`
-    );
+    state.behindTeams = nextBehindTeams;
+    return statuses.flatMap((status) => status.warning ? [status.warning] : []);
+  } finally {
+    state.lastCheckedAt = Date.now();
   }
-  const projectCounts = /* @__PURE__ */ new Map();
-  for (const uri of activeUris) {
-    const parsed = parsePersonalMemoryUri(uri, options.user);
-    if (!parsed || parsed.kind !== "handoff" || parsed.status !== "active") {
-      continue;
-    }
-    projectCounts.set(parsed.project, (projectCounts.get(parsed.project) ?? 0) + 1);
+}
+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 fetchShareUpdateStatuses(config2) {
+  const teamsFile = await readTeamsFile(config2);
+  const teams = Object.entries(teamsFile.teams);
+  if (teams.length === 0) {
+    return [];
   }
-  for (const [project, count] of [...projectCounts.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-    if (count < 10) {
+  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;
     }
-    nudges.push(
-      `Many active handoffs surfaced for ${project}; run compact_context({"project":"${project}","dryRun":true}).`
-    );
-  }
-  return [...new Set(nudges)];
-}
-function activePersonalMemoryUrisFromText(text, user) {
-  const userSegment = uriSegment(user);
-  const matches = text.matchAll(/viking:\/\/[^\s)]+/g);
-  const uris = [];
-  for (const match of matches) {
-    const uri = match[0]?.replace(/[.,;:]+$/g, "");
-    if (!uri || !parsePersonalMemoryUri(uri, userSegment)) {
+    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;
     }
-    uris.push(uri);
+    statuses.push({ behind: Number.parseInt(behind, 10) || 0, team: name });
   }
-  return [...new Set(uris)];
+  return statuses;
 }
-function parsePersonalMemoryUri(uri, user) {
-  const prefix = `viking://user/${uriSegment(user)}/memories/`;
-  if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
-    return void 0;
+async function runShareSyncQuiet(config2, state, options) {
+  const team = await resolveTeam(config2, options.team);
+  const git = await requiredExecutable("git");
+  const worktree = team.config.worktree;
+  const pendingChanges = state.pendingReindexes.get(team.name);
+  if (pendingChanges && pendingChanges.length > 0) {
+    await applyAndPersistChanges(config2, team.config, state, pendingChanges, { quiet: true });
   }
-  const rest = uri.slice(prefix.length);
-  const parts = rest.split("/").filter(Boolean);
-  if (parts.length < 4) {
-    return void 0;
+  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.`;
   }
-  if (parts[0] === "handoffs" && parts[1] === "active" && parts[2] && parts[3]?.endsWith(".md")) {
-    return { kind: "handoff", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
+  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.`;
   }
-  if (parts[0] === "durable" && parts[1] === "projects" && parts[2] && parts[3]?.endsWith(".md")) {
-    return { kind: "durable", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
+  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.`;
   }
-  if (parts[0] === "incidents" && parts[1] === "active" && parts[2] && parts[3]?.endsWith(".md")) {
-    return { kind: "incident", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
+  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_path3.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path3.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) {
+      const stillPending = state.pendingReindexes.get(team.name) ?? [];
+      const combined = mergeChanges(stillPending, changes);
+      await applyAndPersistChanges(config2, team.config, state, combined, { quiet: true });
+    }
   }
   return void 0;
 }
-function groupableRecord(record2) {
-  if (record2.metadata.status !== "active" || !isCompactableKind(record2.metadata.kind)) {
-    return void 0;
+async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
+  const dryRun = options.dryRun === true;
+  const push = options.push !== false;
+  const verb = options.verb ?? "add";
+  const git = await requiredExecutable("git");
+  const messages = [];
+  const paths = typeof relativePath === "string" ? [relativePath] : [...relativePath];
+  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", ...paths] : ["-C", worktree, "add", "--", ...paths];
+  const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
+  if (stageResult) {
+    messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
   }
-  const project = normalizeOptionalMetadata(record2.metadata.project) ?? parseProjectFromUri(record2.uri);
-  if (!project) {
-    return void 0;
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "commit", "-m", commitMessage])}`);
+  } else {
+    const commitResult = await runCommand(git, ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
+    if (commitResult.exitCode !== 0) {
+      const detail = commitResult.stdout.trim() || commitResult.stderr.trim();
+      if (/nothing to commit|no changes added/i.test(detail)) {
+        messages.push("git commit: nothing to commit (file already in tree)");
+      } else {
+        throw new Error(`git commit failed: ${detail || "unknown error"}`);
+      }
+    } else {
+      messages.push(`git commit: ${commitResult.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
+    }
   }
-  const topic = topicForRecord(record2);
-  const groupKey = [record2.metadata.kind, project, topic ?? record2.uri].join("\0");
-  return { groupKey, project, record: record2, topic };
-}
-function topicForRecord(record2) {
-  return normalizeOptionalMetadata(record2.metadata.topic) ?? normalizeOptionalMetadata(branchFromBody(record2.body)) ?? topicFromUri(record2.uri);
+  if (!push) {
+    messages.push("git push skipped (push=false)");
+    return messages;
+  }
+  const pushResult = await runGitCommand(
+    dryRun,
+    git,
+    ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME],
+    "git push failed"
+  );
+  if (pushResult) {
+    messages.push(`git push: ${pushResult.stdout.trim() || pushResult.stderr.trim() || "ok"}`);
+  }
+  return messages;
 }
-function branchFromBody(body) {
-  const branch = /^branch:\s*(.+)$/m.exec(body)?.[1]?.trim();
-  return branch?.split(/\s+/)[0]?.replace(/[.,;:]+$/g, "");
+async function runGitCommand(dryRun, git, args, failureLabel) {
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, args)}`);
+    return void 0;
+  }
+  const result = await runCommand(git, args, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    throw new Error(`${failureLabel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+  }
+  return result;
 }
-function topicFromUri(uri) {
-  const name = (0, import_node_path3.basename)(uri).replace(/\.md$/, "");
-  return name.startsWith("threadnote-") ? void 0 : name;
+async function shareAgentArtifact(config2, sourcePath, options) {
+  const team = await resolveTeam(config2, options.team);
+  const resolvedSourcePath = expandPath(sourcePath);
+  if (!await isRegularFileNoSymlink(resolvedSourcePath)) {
+    throw new Error(`Agent artifact source is not a regular file: ${resolvedSourcePath}`);
+  }
+  const artifact = inferShareArtifact(resolvedSourcePath, options);
+  if (artifact.kind === "skill") {
+    const skillDir = (0, import_node_path3.dirname)(resolvedSourcePath);
+    const members = await collectBundleMemberFiles(skillDir);
+    if (members.length > 1) {
+      return shareBundleArtifact(config2, team, artifact, skillDir, members, options);
+    }
+  }
+  return shareSingleArtifact(config2, team, resolvedSourcePath, artifact, options);
 }
-function parseProjectFromUri(uri) {
-  const parts = uri.split("/memories/")[1]?.split("/").filter(Boolean) ?? [];
-  if ((parts[0] === "handoffs" || parts[0] === "incidents") && parts[1] === "active") {
-    return parts[2];
+async function shareSingleArtifact(config2, team, resolvedSourcePath, artifact, options) {
+  const dryRun = options.dryRun === true;
+  const preview = options.preview === true;
+  const rawContent = await (0, import_promises4.readFile)(resolvedSourcePath, "utf8");
+  if (!rawContent.trim()) {
+    throw new Error(`Refusing to share empty agent artifact: ${resolvedSourcePath}`);
   }
-  if (parts[0] === "durable" && parts[1] === "projects") {
-    return parts[2];
+  const scrub = applyScrubber(rawContent, { redact: options.redact === true });
+  const relativePath = sharedArtifactRelativePath(artifact);
+  const targetPath = (0, import_node_path3.join)(team.config.worktree, ...relativePath.split("/"));
+  const targetUri = workfileToVikingUri(config2, team.config, targetPath);
+  const messages = [
+    `${preview ? "Previewing" : dryRun ? "Would share" : "Sharing"} ${artifact.kind} ${artifact.agent}/${artifact.name}`,
+    `Source: ${portablePath(resolvedSourcePath)}`,
+    `Destination: ${targetUri}`
+  ];
+  if (preview) {
+    if (scrub.blocker) {
+      messages.push(`PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or pass --redact.`);
+      return {
+        artifact,
+        gitMessages: [],
+        messages,
+        sourcePath: resolvedSourcePath,
+        targetPath,
+        targetUri
+      };
+    }
+    for (const redaction of scrub.redactions) {
+      messages.push(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
+    }
+    return {
+      artifact,
+      gitMessages: [],
+      messages,
+      previewContent: scrub.cleaned,
+      sourcePath: resolvedSourcePath,
+      targetPath,
+      targetUri
+    };
   }
-  return void 0;
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to share ${resolvedSourcePath}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
+    );
+  }
+  for (const redaction of scrub.redactions) {
+    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before sharing.`);
+  }
+  const content = scrub.cleaned;
+  const existingContent = await readFileIfExists(targetPath) ?? void 0;
+  if (existingContent !== void 0 && existingContent !== content && options.force !== true) {
+    throw new Error(
+      `Shared artifact already exists with different content: ${portablePath(targetPath)}. Pass --force to replace it.`
+    );
+  }
+  if (dryRun) {
+    messages.push(`Would write shared artifact: ${portablePath(targetPath)}`);
+  }
+  const ov = await openVikingCliForMode(dryRun);
+  const ovHasResource = !dryRun && await vikingResourceExists(ov, config2, targetUri);
+  await ensureSharedDirectoryChain(config2, ov, targetUri, dryRun, { quiet: true });
+  await writeMemoryFile(config2, ov, targetUri, content, ovHasResource ? "replace" : "create", dryRun, { quiet: true });
+  const message = options.message ?? `share: publish ${relativePath}`;
+  const gitMessages = await publishShareGitChange(team.config.worktree, relativePath, message, {
+    dryRun,
+    push: options.push
+  });
+  return { artifact, gitMessages, messages, sourcePath: resolvedSourcePath, targetPath, targetUri };
 }
-function comparableMemoryBody(body) {
-  return stripHygieneSources(body).trim().replace(/\s+/g, " ");
+async function shareBundleArtifact(config2, team, artifact, skillDir, members, options) {
+  const dryRun = options.dryRun === true;
+  const preview = options.preview === true;
+  const skillRootRelative = `${SHAREABLE_ARTIFACT_DIR}/skills/${artifact.agent}/${artifact.name}`;
+  const skillRootTargetDir = (0, import_node_path3.join)(team.config.worktree, ...skillRootRelative.split("/"));
+  const skillMdTargetPath = (0, import_node_path3.join)(skillRootTargetDir, "SKILL.md");
+  const skillMdTargetUri = workfileToVikingUri(config2, team.config, skillMdTargetPath);
+  const skillRootTargetUri = parentUri(skillMdTargetUri);
+  const skillMdSourcePath = (0, import_node_path3.join)(skillDir, "SKILL.md");
+  const prepared = await Promise.all(
+    members.map((member) => prepareBundleMember(config2, team, member, skillRootTargetDir, options))
+  );
+  const skillMd = prepared.find((entry) => entry.relativePath === "SKILL.md");
+  if (skillMd === void 0) {
+    throw new Error(`Skill bundle ${artifact.agent}/${artifact.name} is missing SKILL.md.`);
+  }
+  if (!skillMd.binary && typeof skillMd.content === "string" && !skillMd.content.trim()) {
+    throw new Error(`Refusing to share empty agent artifact: ${skillMdSourcePath}`);
+  }
+  const messages = [
+    `${preview ? "Previewing" : dryRun ? "Would share" : "Sharing"} skill ${artifact.agent}/${artifact.name} bundle (${prepared.length} files)`,
+    `Source: ${portablePath(skillDir)}`,
+    `Destination: ${skillRootTargetUri}/`
+  ];
+  const blockers = prepared.filter((entry) => entry.blocker !== void 0);
+  if (preview) {
+    for (const entry of prepared) {
+      const flags = entry.binary ? ["binary"] : [];
+      for (const redaction of entry.redactions) {
+        flags.push(`redact ${redaction.count}\xD7 ${redaction.name}`);
+      }
+      const note = entry.blocker !== void 0 ? ` BLOCKED: ${entry.blocker}` : "";
+      messages.push(`  ${entry.relativePath}${flags.length > 0 ? ` [${flags.join(", ")}]` : ""}${note}`);
+    }
+    return {
+      artifact,
+      gitMessages: [],
+      messages,
+      previewContent: skillMd.binary ? void 0 : skillMd.content,
+      sourcePath: skillMdSourcePath,
+      targetPath: skillMdTargetPath,
+      targetUri: skillMdTargetUri
+    };
+  }
+  if (blockers.length > 0) {
+    throw new Error(
+      `Refusing to share skill ${artifact.agent}/${artifact.name}: ${blockers.map((entry) => `${entry.relativePath} (${entry.blocker})`).join("; ")}. Strip the value, pass --redact for local paths, or --allow-binary for binary files.`
+    );
+  }
+  for (const entry of prepared) {
+    for (const redaction of entry.redactions) {
+      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} in ${entry.relativePath} before sharing.`);
+    }
+  }
+  for (const entry of prepared) {
+    const existing = await readFileBytesIfExists(entry.targetPath);
+    if (existing !== void 0 && sha256(existing) !== entry.sha256 && options.force !== true) {
+      throw new Error(
+        `Shared artifact already exists with different content: ${portablePath(entry.targetPath)}. Pass --force to replace it.`
+      );
+    }
+  }
+  if (dryRun) {
+    messages.push(`Would write ${prepared.length} files under ${portablePath(skillRootTargetDir)}`);
+    return {
+      artifact,
+      gitMessages: [],
+      messages,
+      sourcePath: skillMdSourcePath,
+      targetPath: skillMdTargetPath,
+      targetUri: skillMdTargetUri
+    };
+  }
+  const ov = await openVikingCliForMode(dryRun);
+  const markdownMembers = orderSkillMdFirst(prepared.filter((entry) => entry.relativePath.endsWith(".md")));
+  const otherMembers = prepared.filter((entry) => !entry.relativePath.endsWith(".md"));
+  for (const entry of markdownMembers) {
+    const ovHasResource = await vikingResourceExists(ov, config2, entry.targetUri);
+    await ensureSharedDirectoryChain(config2, ov, entry.targetUri, dryRun, { quiet: true });
+    await writeMemoryFile(
+      config2,
+      ov,
+      entry.targetUri,
+      entry.content,
+      ovHasResource ? "replace" : "create",
+      dryRun,
+      { quiet: true }
+    );
+  }
+  await ensureDirectory(skillRootTargetDir, false);
+  for (const entry of otherMembers) {
+    await ensureDirectory((0, import_node_path3.dirname)(entry.targetPath), false);
+    await (0, import_promises4.writeFile)(entry.targetPath, entry.content, entry.binary ? { mode: 384 } : { encoding: "utf8", mode: 384 });
+  }
+  await (0, import_promises4.writeFile)((0, import_node_path3.join)(skillRootTargetDir, BUNDLE_MANIFEST_FILE), buildBundleManifest(artifact, prepared), {
+    encoding: "utf8",
+    mode: 384
+  });
+  const stagedPaths = [
+    ...prepared.map((entry) => `${skillRootRelative}/${entry.relativePath}`),
+    `${skillRootRelative}/${BUNDLE_MANIFEST_FILE}`
+  ];
+  const message = options.message ?? `share: publish skill ${artifact.agent}/${artifact.name} (${prepared.length} files)`;
+  const gitMessages = await publishShareGitChange(team.config.worktree, stagedPaths, message, {
+    dryRun,
+    push: options.push
+  });
+  return {
+    artifact,
+    gitMessages,
+    messages,
+    sourcePath: skillMdSourcePath,
+    targetPath: skillMdTargetPath,
+    targetUri: skillMdTargetUri
+  };
 }
-function stripHygieneSources(body) {
-  const index = body.indexOf(`
-${HYGIENE_SOURCES_HEADING}`);
-  if (index !== -1) {
-    return body.slice(0, index).trim();
+async function prepareBundleMember(config2, team, member, skillRootTargetDir, options) {
+  const buffer = await (0, import_promises4.readFile)(member.absolutePath);
+  const targetPath = (0, import_node_path3.join)(skillRootTargetDir, ...member.relativePath.split("/"));
+  const targetUri = workfileToVikingUri(config2, team.config, targetPath);
+  if (isProbablyBinary(buffer)) {
+    const credential = detectBinaryCredential(buffer);
+    const blocker = credential !== void 0 ? `possible ${credential} embedded in binary file` : options.allowBinary === true ? void 0 : "binary file (pass --allow-binary to include it unscanned)";
+    return {
+      binary: true,
+      blocker,
+      content: buffer,
+      redactions: [],
+      relativePath: member.relativePath,
+      sha256: sha256(buffer),
+      targetPath,
+      targetUri
+    };
   }
-  return body.startsWith(HYGIENE_SOURCES_HEADING) ? "" : body.trim();
+  const scrub = applyScrubber(buffer.toString("utf8"), { redact: options.redact === true });
+  return {
+    binary: false,
+    blocker: scrub.blocker,
+    content: scrub.cleaned,
+    redactions: scrub.redactions,
+    relativePath: member.relativePath,
+    sha256: sha256(scrub.cleaned),
+    targetPath,
+    targetUri
+  };
 }
-function preferredKeepRecord(records, topic) {
-  const stableRecords = records.filter((record2) => isStableRecord(record2, topic));
-  return sortedNewestFirst(stableRecords.length > 0 ? stableRecords : records)[0] ?? records[0];
+function orderSkillMdFirst(entries) {
+  return [...entries].sort((a, b) => {
+    if (a.relativePath === "SKILL.md") {
+      return -1;
+    }
+    if (b.relativePath === "SKILL.md") {
+      return 1;
+    }
+    return compareStrings(a.relativePath, b.relativePath);
+  });
 }
-function isStableRecord(record2, topic) {
-  const recordTopic = topic ?? topicForRecord(record2);
-  return recordTopic !== void 0 && (0, import_node_path3.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
+function buildBundleManifest(artifact, prepared) {
+  const manifest = {
+    artifact,
+    members: prepared.map((entry) => ({ binary: entry.binary, path: entry.relativePath, sha256: entry.sha256 })).sort((a, b) => compareStrings(a.path, b.path)),
+    version: BUNDLE_MANIFEST_VERSION
+  };
+  return `${JSON.stringify(manifest, void 0, 2)}
+`;
 }
-function sortedNewestFirst(records) {
-  return [...records].sort((left, right) => {
-    const timestampDiff = timestampMs(right) - timestampMs(left);
-    return timestampDiff === 0 ? left.uri.localeCompare(right.uri) : timestampDiff;
-  });
+async function collectBundleMemberFiles(skillDir) {
+  const out = [];
+  async function visit(dir) {
+    const entries = await (0, import_promises4.readdir)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      const full = (0, import_node_path3.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!BUNDLE_IGNORE_DIR_NAMES.includes(entry.name)) {
+          await visit(full);
+        }
+        continue;
+      }
+      if (!entry.isFile() || isIgnoredBundleFile(entry.name)) {
+        continue;
+      }
+      out.push({ absolutePath: full, relativePath: (0, import_node_path3.relative)(skillDir, full).split(import_node_path3.sep).join("/") });
+    }
+  }
+  await visit(skillDir);
+  return out.sort((a, b) => compareStrings(a.relativePath, b.relativePath));
 }
-function timestampMs(record2) {
-  const parsed = Date.parse(record2.metadata.timestamp);
-  return Number.isFinite(parsed) ? parsed : 0;
+function isIgnoredBundleFile(name) {
+  if (name === ".DS_Store" || name === BUNDLE_MANIFEST_FILE || name === BUNDLE_INSTALL_METADATA_FILE) {
+    return true;
+  }
+  if (OV_SUMMARY_FILES.includes(name)) {
+    return true;
+  }
+  return name.endsWith(".log") || name.endsWith(".threadnote-install.json");
 }
-function isStaleLookingHandoff(record2, now) {
-  if (record2.metadata.kind !== "handoff") {
-    return false;
+function isProbablyBinary(buffer) {
+  if (buffer.includes(0)) {
+    return true;
   }
-  if (now.getTime() - timestampMs(record2) < STALE_HANDOFF_AGE_MS) {
+  try {
+    new import_node_util.TextDecoder("utf-8", { fatal: true }).decode(buffer);
     return false;
+  } catch (_err) {
+    return true;
   }
-  return /\b(?:PR|pull request)\s+(?:OPEN|open|is open)|awaiting review|waiting for review|next steps?:\s*address PR review/i.test(
-    record2.body
-  );
 }
-function groupBy(values, keyForValue) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const key = keyForValue(value);
-    groups.set(key, [...groups.get(key) ?? [], value]);
+function detectBinaryCredential(buffer) {
+  const latin1 = buffer.toString("latin1");
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (pattern.placeholder === void 0 && pattern.regex.test(latin1)) {
+      return pattern.name;
+    }
   }
-  return groups;
-}
-function compareGroupedRecordLists(left, right) {
-  return (left[0]?.groupKey ?? "").localeCompare(right[0]?.groupKey ?? "");
+  return void 0;
 }
-function dedupeByUri(items) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const item of items) {
-    if (seen.has(item.uri)) {
-      continue;
+function detectBinaryLocalPath(buffer, rewriteRoots) {
+  const latin1 = buffer.toString("latin1");
+  for (const root of rewriteRoots) {
+    if (root.length > 0 && latin1.includes(root)) {
+      return "machine-local path";
     }
-    seen.add(item.uri);
-    result.push(item);
   }
-  return result;
-}
-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 headerValue(header, key) {
-  const prefix = `${key}:`;
-  return header.split("\n").find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
-}
-function parseOptionalMemoryKind(value) {
-  if (!value) {
-    return void 0;
-  }
-  if (["durable", "handoff", "incident", "preference", "smoke"].includes(value)) {
-    return value;
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (pattern.placeholder !== void 0 && pattern.regex.test(latin1)) {
+      return pattern.name;
+    }
   }
   return void 0;
 }
-function parseOptionalMemoryStatus(value) {
-  if (!value) {
+async function readFileBytesIfExists(path) {
+  try {
+    return await (0, import_promises4.readFile)(path);
+  } catch (_err) {
     return void 0;
   }
-  if (["active", "archived", "superseded"].includes(value)) {
-    return value;
-  }
-  return void 0;
 }
-function normalizeOptionalMetadata(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
+function isBundleArtifact(artifact) {
+  if (artifact.artifact.kind === "pack") {
+    return true;
+  }
+  return artifact.members !== void 0 && artifact.members.length > 1;
 }
-function isCompactableKind(kind) {
-  return kind === "durable" || kind === "handoff" || kind === "incident";
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
 }
-function memoryKindPlural(kind) {
-  switch (kind) {
-    case "handoff":
-      return "handoffs";
-    case "incident":
-      return "incidents";
-    case "durable":
-      return "durable memories";
-    case "preference":
-      return "preferences";
-    case "smoke":
-      return "smoke memories";
+function parsePackManifest(raw, manifestPath) {
+  const parsed = parseJsonConfigObject(raw);
+  if (parsed === void 0) {
+    throw new Error(`Invalid pack manifest (not a JSON object): ${manifestPath}`);
   }
-}
-function formatPlanSection(title, lines) {
-  if (lines.length === 0) {
-    return `${title}:
-- none`;
+  const name = parsed.name;
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error(`Pack manifest must set a non-empty "name": ${manifestPath}`);
   }
-  return [`${title}:`, ...lines.map((line) => `- ${line}`)].join("\n");
-}
-
-// src/share.ts
-var import_promises4 = require("node:fs/promises");
-var import_node_os2 = 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 SHAREABLE_ARTIFACT_DIR = "agent-artifacts";
-var SHAREABLE_TOP_LEVEL_DIRS = [...SHAREABLE_MEMORY_KIND_DIRS, SHAREABLE_ARTIFACT_DIR];
-var ARTIFACT_INSTALL_METADATA_VERSION = 1;
-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 });
+  const agent = parsed.agent;
+  if (agent !== "codex" && agent !== "claude") {
+    throw new Error(`Pack manifest "agent" must be "codex" or "claude": ${manifestPath}`);
   }
-  return { cleaned, redactions };
-}
-var autoShareStates = /* @__PURE__ */ new Map();
-function startShareBackgroundFetch(config2) {
-  const state = autoShareState(config2);
-  if (state.timer) {
-    return;
+  const stringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  const skills = stringArray(parsed.skills);
+  if (skills.length === 0) {
+    throw new Error(`Pack manifest must list at least one skill in "skills": ${manifestPath}`);
   }
-  void refreshShareUpdateState(config2, { force: true }).catch((err) => {
-    console.error(`share auto-fetch failed: ${err instanceof Error ? err.message : String(err)}`);
-  });
-  state.timer = setInterval(() => {
-    void refreshShareUpdateState(config2, { force: false }).catch((err) => {
-      console.error(`share auto-fetch failed: ${err instanceof Error ? err.message : String(err)}`);
-    });
-  }, AUTO_SHARE_FETCH_INTERVAL_MS);
-  state.timer.unref?.();
+  const depsValue = parsed.deps ?? {};
+  const pathRewrites = Array.isArray(parsed.pathRewrites) ? parsed.pathRewrites.map((entry) => typeof entry === "string" ? entry : entry?.from).filter((item) => typeof item === "string").map((rewrite) => rewrite.replace(/\/+$/, "")) : [];
+  for (const rewrite of pathRewrites) {
+    if (!(0, import_node_path3.isAbsolute)(rewrite) || rewrite.split("/").filter(Boolean).length < 2) {
+      throw new Error(
+        `Pack manifest pathRewrites entry must be an absolute repo-root path (got "${rewrite}"): ${manifestPath}`
+      );
+    }
+  }
+  return {
+    agent,
+    deps: {
+      cli: stringArray(depsValue.cli),
+      mcp: stringArray(depsValue.mcp),
+      os: stringArray(depsValue.os),
+      runtime: stringArray(depsValue.runtime)
+    },
+    description: typeof parsed.description === "string" ? parsed.description : void 0,
+    include: stringArray(parsed.include),
+    name,
+    pathRewrites,
+    skills
+  };
 }
-async function syncSharedReposBeforeAgentRead(config2) {
-  const state = autoShareState(config2);
-  return enqueueShareOperation(state, async () => {
-    await loadPendingReindexes(config2, state);
-    const warnings = await refreshShareUpdateStateLocked(config2, state, { force: false });
-    const syncTeams = /* @__PURE__ */ new Set([...state.behindTeams, ...state.pendingReindexes.keys()]);
-    if (syncTeams.size === 0) {
-      return { syncedTeams: [], warnings };
+async function collectPackMembers(manifestDir, manifest) {
+  const members = /* @__PURE__ */ new Map();
+  const addEntry = async (entry) => {
+    const normalized = entry.split("/").filter(Boolean).join("/");
+    if (normalized.split("/").includes("..")) {
+      throw new Error(`Pack manifest entries must stay within the pack root (got "${entry}").`);
     }
-    const syncedTeams = [];
-    const remainingBehind = new Set(state.behindTeams);
-    for (const team of syncTeams) {
-      try {
-        const warning2 = await runShareSyncQuiet(config2, state, { team });
-        if (warning2) {
-          warnings.push(warning2);
-        } 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)}`
-        );
+    const absolute = (0, import_node_path3.join)(manifestDir, ...normalized.split("/"));
+    if (absolute !== manifestDir && !absolute.startsWith(manifestDir + import_node_path3.sep)) {
+      throw new Error(`Pack manifest entry escapes the pack root: ${entry}`);
+    }
+    if (await isDirectory(absolute)) {
+      for (const member of await collectBundleMemberFiles(absolute)) {
+        const relativePath = `${normalized}/${member.relativePath}`;
+        members.set(relativePath, { absolutePath: member.absolutePath, relativePath });
       }
+      return;
     }
-    state.behindTeams = remainingBehind;
-    state.lastCheckedAt = Date.now();
-    return { syncedTeams, warnings };
-  });
-}
-function autoShareState(config2) {
-  const key = `${config2.agentContextHome}:${config2.account}:${config2.user}`;
-  let state = autoShareStates.get(key);
-  if (!state) {
-    state = { behindTeams: /* @__PURE__ */ new Set(), lastCheckedAt: 0, pendingReindexes: /* @__PURE__ */ new Map() };
-    autoShareStates.set(key, state);
+    if (await isRegularFileNoSymlink(absolute)) {
+      members.set(normalized, { absolutePath: absolute, relativePath: normalized });
+      return;
+    }
+    throw new Error(`Pack manifest references a missing path: ${entry}`);
+  };
+  for (const skill of manifest.skills) {
+    const skillRel = skill.replace(/\/SKILL\.md$/i, "");
+    const skillDir = (0, import_node_path3.join)(manifestDir, ...skillRel.split("/"));
+    if (!await isFile((0, import_node_path3.join)(skillDir, "SKILL.md"))) {
+      throw new Error(`Pack skill "${skill}" must be a directory containing SKILL.md.`);
+    }
+    await addEntry(skillRel);
   }
-  return state;
+  for (const include of manifest.include) {
+    await addEntry(include);
+  }
+  return [...members.values()].sort((a, b) => compareStrings(a.relativePath, b.relativePath));
 }
-function pendingReindexesPath(config2) {
-  return (0, import_node_path4.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function loadPendingReindexes(config2, state) {
-  const raw = await readFileIfExists(pendingReindexesPath(config2));
-  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;
-      }
-      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 });
-      }
+function tokenizePackPaths(text, rewriteRoots) {
+  let out = text;
+  for (const root of rewriteRoots) {
+    if (root.length > 0) {
+      out = out.replace(
+        new RegExp(`(?<![A-Za-z0-9/._~-])${escapeRegExp(root)}(?=[/\\\\]|["'\`\\s),>:\\]};=]|$)`, "g"),
+        PACK_ROOT_TOKEN
+      );
     }
-    if (changes.length > 0) {
-      pending.set(team, changes);
+  }
+  return out;
+}
+function residualRewriteRoot(content, rewriteRoots) {
+  return rewriteRoots.find((root) => root.length > 0 && content.includes(root));
+}
+var PORTABLE_PATH_PREFIXES = [
+  "/usr/",
+  "/bin/",
+  "/sbin/",
+  "/lib/",
+  "/lib64/",
+  "/etc/",
+  "/opt/homebrew/",
+  "/tmp/",
+  "/var/",
+  "/private/var/",
+  "/dev/",
+  "/proc/",
+  "/run/",
+  "/sys/",
+  "/Library/",
+  "/System/",
+  "/Applications/"
+];
+function unportableAbsolutePaths(content) {
+  const scan = content.split(`${PACK_ROOT_TOKEN}/`).join("").split(PACK_ROOT_TOKEN).join("");
+  const found = /* @__PURE__ */ new Set();
+  for (const path of scan.match(/(?<![A-Za-z0-9._~$-])\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)+/g) ?? []) {
+    if (!PORTABLE_PATH_PREFIXES.some((prefix) => path.startsWith(prefix))) {
+      found.add(path);
     }
   }
-  state.pendingReindexes = pending;
+  for (const path of scan.match(/[A-Za-z]:\\[^\s"']+/g) ?? []) {
+    found.add(path);
+  }
+  return [...found].sort((a, b) => compareStrings(a, b));
 }
-async function writePendingReindexes(config2, state) {
-  const path = pendingReindexesPath(config2);
-  if (state.pendingReindexes.size === 0) {
-    await (0, import_promises4.rm)(path, { force: true });
-    return;
+async function preparePackMember(config2, team, member, filesTargetDir, rewriteRoots, options) {
+  const buffer = await (0, import_promises4.readFile)(member.absolutePath);
+  const targetPath = (0, import_node_path3.join)(filesTargetDir, ...member.relativePath.split("/"));
+  const targetUri = workfileToVikingUri(config2, team.config, targetPath);
+  if (isProbablyBinary(buffer)) {
+    const credential = detectBinaryCredential(buffer);
+    const localPath = credential === void 0 ? detectBinaryLocalPath(buffer, rewriteRoots) : void 0;
+    let blocker2;
+    if (credential !== void 0) {
+      blocker2 = `possible ${credential} embedded in binary file`;
+    } else if (options.allowBinary !== true) {
+      blocker2 = "binary file (pass --allow-binary to include it unscanned)";
+    } else if (localPath !== void 0) {
+      blocker2 = `possible ${localPath} embedded in binary file (cannot be rewritten)`;
+    }
+    return {
+      binary: true,
+      blocker: blocker2,
+      content: buffer,
+      redactions: [],
+      relativePath: member.relativePath,
+      sha256: sha256(buffer),
+      targetPath,
+      targetUri
+    };
   }
-  const contents = {
-    teams: Object.fromEntries(state.pendingReindexes),
-    version: 1
+  const text = buffer.toString("utf8");
+  if (text.includes(PACK_ROOT_TOKEN)) {
+    return {
+      binary: false,
+      blocker: `contains the reserved ${PACK_ROOT_TOKEN} token`,
+      content: text,
+      redactions: [],
+      relativePath: member.relativePath,
+      sha256: sha256(text),
+      targetPath,
+      targetUri
+    };
+  }
+  const tokenized = tokenizePackPaths(text, rewriteRoots);
+  const isMarkdown = member.relativePath.toLowerCase().endsWith(".md");
+  const scrub = applyScrubber(tokenized, { redact: isMarkdown && options.redact === true });
+  const residual = residualRewriteRoot(scrub.cleaned, rewriteRoots);
+  const blocker = scrub.blocker ?? (residual !== void 0 ? `machine-local path "${residual}" not rewritten` : void 0);
+  return {
+    binary: false,
+    blocker,
+    content: scrub.cleaned,
+    redactions: scrub.redactions,
+    relativePath: member.relativePath,
+    sha256: sha256(scrub.cleaned),
+    targetPath,
+    targetUri
   };
-  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 refreshShareUpdateState(config2, options) {
-  const state = autoShareState(config2);
-  const warnings = await enqueueShareOperation(
-    state,
-    async () => refreshShareUpdateStateLocked(config2, state, options)
-  );
-  for (const warning2 of warnings) {
-    console.error(warning2);
+function buildPackIndex(artifact, manifest, skillNames, memberCount) {
+  const lines = [
+    "---",
+    `name: ${artifact.name}`,
+    `agent: ${artifact.agent}`,
+    "kind: pack",
+    `skills: [${skillNames.join(", ")}]`,
+    "---",
+    "",
+    `# ${artifact.name} (skill pack)`,
+    "",
+    manifest.description ?? `A Threadnote skill pack bundling ${skillNames.length} skill(s) and their shared support files (${memberCount} files total).`,
+    "",
+    "## Skills",
+    ...skillNames.map((skill) => `- ${skill}`),
+    "",
+    "## Requirements",
+    "Threadnote installs files only. Ensure these exist on the target machine before running:"
+  ];
+  if (manifest.deps.runtime.length > 0) {
+    lines.push(`- runtime: ${manifest.deps.runtime.join(", ")}`);
   }
-}
-async function refreshShareUpdateStateLocked(config2, state, options) {
-  const now = Date.now();
-  if (!options.force && state.lastCheckedAt > 0 && now - state.lastCheckedAt < AUTO_SHARE_FETCH_INTERVAL_MS) {
-    return [];
-  }
-  try {
-    const statuses = await fetchShareUpdateStatuses(config2);
-    const nextBehindTeams = new Set(state.behindTeams);
-    for (const status of statuses) {
-      if (status.warning) {
-        continue;
-      }
-      if (status.behind > 0) {
-        nextBehindTeams.add(status.team);
-      } else {
-        nextBehindTeams.delete(status.team);
-      }
-    }
-    state.behindTeams = nextBehindTeams;
-    return statuses.flatMap((status) => status.warning ? [status.warning] : []);
-  } finally {
-    state.lastCheckedAt = Date.now();
-  }
-}
-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 fetchShareUpdateStatuses(config2) {
-  const teamsFile = await readTeamsFile(config2);
-  const teams = Object.entries(teamsFile.teams);
-  if (teams.length === 0) {
-    return [];
-  }
-  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 });
-  }
-  return statuses;
-}
-async function runShareSyncQuiet(config2, state, options) {
-  const team = await resolveTeam(config2, options.team);
-  const git = await requiredExecutable("git");
-  const worktree = team.config.worktree;
-  const pendingChanges = state.pendingReindexes.get(team.name);
-  if (pendingChanges && pendingChanges.length > 0) {
-    await applyAndPersistChanges(config2, team.config, state, pendingChanges, { quiet: true });
-  }
-  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.`;
+  if (manifest.deps.cli.length > 0) {
+    lines.push(`- CLI: ${manifest.deps.cli.join(", ")}`);
   }
-  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.`;
-  }
-  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 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"}`
-    );
+  if (manifest.deps.os.length > 0) {
+    lines.push(`- OS: ${manifest.deps.os.join(", ")}`);
   }
-  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) {
-      const stillPending = state.pendingReindexes.get(team.name) ?? [];
-      const combined = mergeChanges(stillPending, changes);
-      await applyAndPersistChanges(config2, team.config, state, combined, { quiet: true });
-    }
+  if (manifest.deps.mcp.length > 0) {
+    lines.push(`- MCP (configure separately): ${manifest.deps.mcp.join(", ")}`);
   }
-  return void 0;
+  lines.push("", `Install: threadnote share install-artifacts --kind pack --name ${artifact.name} --apply`, "");
+  return lines.join("\n");
 }
-async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
-  const dryRun = options.dryRun === true;
-  const push = options.push !== false;
-  const verb = options.verb ?? "add";
-  const git = await requiredExecutable("git");
-  const messages = [];
-  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", relativePath] : ["-C", worktree, "add", "--", relativePath];
-  const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
-  if (stageResult) {
-    messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
-  }
-  if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "commit", "-m", commitMessage])}`);
-  } else {
-    const commitResult = await runCommand(git, ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
-    if (commitResult.exitCode !== 0) {
-      const detail = commitResult.stdout.trim() || commitResult.stderr.trim();
-      if (/nothing to commit|no changes added/i.test(detail)) {
-        messages.push("git commit: nothing to commit (file already in tree)");
-      } else {
-        throw new Error(`git commit failed: ${detail || "unknown error"}`);
-      }
-    } else {
-      messages.push(`git commit: ${commitResult.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
-    }
-  }
-  if (!push) {
-    messages.push("git push skipped (push=false)");
-    return messages;
-  }
-  const pushResult = await runGitCommand(
-    dryRun,
-    git,
-    ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME],
-    "git push failed"
-  );
-  if (pushResult) {
-    messages.push(`git push: ${pushResult.stdout.trim() || pushResult.stderr.trim() || "ok"}`);
-  }
-  return messages;
+function buildPackManifestJson(artifact, manifest, prepared) {
+  const data = {
+    artifact,
+    deps: manifest.deps,
+    members: prepared.map((entry) => ({ binary: entry.binary, path: entry.relativePath, sha256: entry.sha256 })).sort((a, b) => compareStrings(a.path, b.path)),
+    version: BUNDLE_MANIFEST_VERSION
+  };
+  return `${JSON.stringify(data, void 0, 2)}
+`;
 }
-async function runGitCommand(dryRun, git, args, failureLabel) {
-  if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(git, args)}`);
-    return void 0;
-  }
-  const result = await runCommand(git, args, { allowFailure: true });
-  if (result.exitCode !== 0) {
-    throw new Error(`${failureLabel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
-  }
-  return result;
+function packSkillName(skillEntry) {
+  const trimmed = skillEntry.replace(/\/SKILL\.md$/i, "");
+  return (0, import_node_path3.basename)(trimmed);
 }
-async function shareAgentArtifact(config2, sourcePath, options) {
+async function shareBundlePack(config2, manifestPath, options) {
   const team = await resolveTeam(config2, options.team);
   const dryRun = options.dryRun === true;
   const preview = options.preview === true;
-  const resolvedSourcePath = expandPath(sourcePath);
-  if (!await isRegularFileNoSymlink(resolvedSourcePath)) {
-    throw new Error(`Agent artifact source is not a regular file: ${resolvedSourcePath}`);
-  }
-  const artifact = inferShareArtifact(resolvedSourcePath, options);
-  const rawContent = await (0, import_promises4.readFile)(resolvedSourcePath, "utf8");
-  if (!rawContent.trim()) {
-    throw new Error(`Refusing to share empty agent artifact: ${resolvedSourcePath}`);
-  }
-  const scrub = applyScrubber(rawContent, { redact: options.redact === true });
-  const relativePath = sharedArtifactRelativePath(artifact);
-  const targetPath = (0, import_node_path4.join)(team.config.worktree, ...relativePath.split("/"));
-  const targetUri = workfileToVikingUri(config2, team.config, targetPath);
+  const resolvedManifest = expandPath(manifestPath);
+  if (!await isRegularFileNoSymlink(resolvedManifest)) {
+    throw new Error(`Pack manifest is not a regular file: ${resolvedManifest}`);
+  }
+  const manifest = parsePackManifest(await (0, import_promises4.readFile)(resolvedManifest, "utf8"), resolvedManifest);
+  const manifestDir = (0, import_node_path3.dirname)(resolvedManifest);
+  const artifact = { agent: manifest.agent, kind: "pack", name: uriSegment(manifest.name) };
+  const skillNames = manifest.skills.map(packSkillName);
+  const members = await collectPackMembers(manifestDir, manifest);
+  const autoRoots = manifestDir.split("/").filter(Boolean).length >= 2 ? [manifestDir] : [];
+  const rewriteRoots = [.../* @__PURE__ */ new Set([...autoRoots, ...manifest.pathRewrites])].sort((a, b) => b.length - a.length);
+  const packRootRelative = `${SHAREABLE_ARTIFACT_DIR}/packs/${artifact.agent}/${artifact.name}`;
+  const filesRelative = `${packRootRelative}/${PACK_FILES_DIR}`;
+  const indexRelative = `${packRootRelative}/${artifact.name}${PACK_INDEX_SUFFIX}`;
+  const manifestRelative = `${packRootRelative}/${artifact.name}${PACK_MANIFEST_SUFFIX}`;
+  const filesTargetDir = (0, import_node_path3.join)(team.config.worktree, ...filesRelative.split("/"));
+  const packRootTargetDir = (0, import_node_path3.join)(team.config.worktree, ...packRootRelative.split("/"));
+  const indexTargetPath = (0, import_node_path3.join)(team.config.worktree, ...indexRelative.split("/"));
+  const indexTargetUri = workfileToVikingUri(config2, team.config, indexTargetPath);
+  const prepared = await Promise.all(
+    members.map((member) => preparePackMember(config2, team, member, filesTargetDir, rewriteRoots, options))
+  );
+  const indexContent = tokenizePackPaths(buildPackIndex(artifact, manifest, skillNames, prepared.length), rewriteRoots);
+  const indexScrub = applyScrubber(indexContent, { redact: options.redact === true });
   const messages = [
-    `${preview ? "Previewing" : dryRun ? "Would share" : "Sharing"} ${artifact.kind} ${artifact.agent}/${artifact.name}`,
-    `Source: ${portablePath(resolvedSourcePath)}`,
-    `Destination: ${targetUri}`
+    `${preview ? "Previewing" : dryRun ? "Would share" : "Sharing"} pack ${artifact.agent}/${artifact.name} (${prepared.length} files, ${skillNames.length} skills)`,
+    `Source: ${portablePath(manifestDir)}`,
+    `Destination: ${indexTargetUri}`
   ];
+  const blockers = prepared.filter((entry) => entry.blocker !== void 0);
   if (preview) {
-    if (scrub.blocker) {
-      messages.push(`PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or pass --redact.`);
-      return {
-        artifact,
-        gitMessages: [],
-        messages,
-        sourcePath: resolvedSourcePath,
-        targetPath,
-        targetUri
-      };
-    }
-    for (const redaction of scrub.redactions) {
-      messages.push(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
+    for (const entry of prepared) {
+      const flags = entry.binary ? ["binary"] : [];
+      for (const redaction of entry.redactions) {
+        flags.push(`redact ${redaction.count}\xD7 ${redaction.name}`);
+      }
+      const note = entry.blocker !== void 0 ? ` BLOCKED: ${entry.blocker}` : "";
+      messages.push(`  ${entry.relativePath}${flags.length > 0 ? ` [${flags.join(", ")}]` : ""}${note}`);
     }
     return {
       artifact,
       gitMessages: [],
       messages,
-      previewContent: scrub.cleaned,
-      sourcePath: resolvedSourcePath,
-      targetPath,
-      targetUri
+      previewContent: indexScrub.cleaned,
+      sourcePath: resolvedManifest,
+      targetPath: indexTargetPath,
+      targetUri: indexTargetUri
     };
   }
-  if (scrub.blocker) {
+  const indexResidual = residualRewriteRoot(indexScrub.cleaned, rewriteRoots);
+  if (indexScrub.blocker !== void 0 || indexResidual !== void 0) {
     throw new Error(
-      `Refusing to share ${resolvedSourcePath}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
+      `Refusing to share pack ${artifact.agent}/${artifact.name}: index ${indexScrub.blocker ?? `machine-local path "${indexResidual}" not rewritten`}.`
     );
   }
-  for (const redaction of scrub.redactions) {
-    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before sharing.`);
+  if (blockers.length > 0) {
+    throw new Error(
+      `Refusing to share pack ${artifact.agent}/${artifact.name}: ${blockers.map((entry) => `${entry.relativePath} (${entry.blocker})`).join("; ")}. Strip the value, pass --redact for local paths, or --allow-binary for binary files.`
+    );
   }
-  const content = scrub.cleaned;
-  const existingContent = await readFileIfExists(targetPath) ?? void 0;
-  if (existingContent !== void 0 && existingContent !== content && options.force !== true) {
+  const packJson = applyScrubber(tokenizePackPaths(buildPackManifestJson(artifact, manifest, prepared), rewriteRoots), {
+    redact: options.redact === true
+  });
+  const packJsonResidual = residualRewriteRoot(packJson.cleaned, rewriteRoots);
+  if (packJson.blocker !== void 0 || packJsonResidual !== void 0) {
     throw new Error(
-      `Shared artifact already exists with different content: ${portablePath(targetPath)}. Pass --force to replace it.`
+      `Refusing to share pack ${artifact.agent}/${artifact.name}: manifest ${packJson.blocker ?? `machine-local path "${packJsonResidual}" not rewritten`}.`
+    );
+  }
+  for (const entry of prepared) {
+    for (const redaction of entry.redactions) {
+      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} in ${entry.relativePath} before sharing.`);
+    }
+  }
+  const unportable = /* @__PURE__ */ new Set();
+  for (const entry of prepared) {
+    if (!entry.binary && typeof entry.content === "string") {
+      for (const path of unportableAbsolutePaths(entry.content)) {
+        unportable.add(`${entry.relativePath}: ${path}`);
+      }
+    }
+  }
+  for (const path of unportableAbsolutePaths(indexScrub.cleaned)) {
+    unportable.add(`${artifact.name}${PACK_INDEX_SUFFIX}: ${path}`);
+  }
+  for (const path of unportableAbsolutePaths(packJson.cleaned)) {
+    unportable.add(`${artifact.name}${PACK_MANIFEST_SUFFIX}: ${path}`);
+  }
+  if (unportable.size > 0) {
+    messages.push(
+      `Warning: possible machine-local absolute path(s) that will not resolve on a teammate's machine (declare in pathRewrites or strip if not portable): ${[...unportable].join("; ")}`
     );
   }
+  for (const entry of prepared) {
+    const existing = await readFileBytesIfExists(entry.targetPath);
+    if (existing !== void 0 && sha256(existing) !== entry.sha256 && options.force !== true) {
+      throw new Error(
+        `Shared pack file already exists with different content: ${portablePath(entry.targetPath)}. Pass --force to replace it.`
+      );
+    }
+  }
   if (dryRun) {
-    messages.push(`Would write shared artifact: ${portablePath(targetPath)}`);
+    messages.push(`Would write ${prepared.length} files under ${portablePath(packRootTargetDir)}`);
+    return {
+      artifact,
+      gitMessages: [],
+      messages,
+      sourcePath: resolvedManifest,
+      targetPath: indexTargetPath,
+      targetUri: indexTargetUri
+    };
   }
   const ov = await openVikingCliForMode(dryRun);
-  const ovHasResource = !dryRun && await vikingResourceExists(ov, config2, targetUri);
-  await ensureSharedDirectoryChain(config2, ov, targetUri, dryRun, { quiet: true });
-  await writeMemoryFile(config2, ov, targetUri, content, ovHasResource ? "replace" : "create", dryRun, { quiet: true });
-  const message = options.message ?? `share: publish ${relativePath}`;
-  const gitMessages = await publishShareGitChange(team.config.worktree, relativePath, message, {
+  const rollbacks = [];
+  const manifestTargetPath = (0, import_node_path3.join)(team.config.worktree, ...manifestRelative.split("/"));
+  try {
+    const writeMarkdownMember = async (uri, content, worktreePath) => {
+      const priorBytes = await readFileBytesIfExists(worktreePath);
+      const hadResource = await vikingResourceExists(ov, config2, uri);
+      await ensureSharedDirectoryChain(config2, ov, uri, dryRun, { quiet: true });
+      await writeMemoryFile(config2, ov, uri, content, hadResource ? "replace" : "create", dryRun, { quiet: true });
+      rollbacks.push(async () => {
+        if (priorBytes !== void 0) {
+          await writeMemoryFile(config2, ov, uri, priorBytes.toString("utf8"), "replace", false, { quiet: true });
+        } else if (await vikingResourceExists(ov, config2, uri)) {
+          await removeMemoryUri(config2, ov, uri, false, { quiet: true });
+        }
+      });
+    };
+    await writeMarkdownMember(indexTargetUri, indexScrub.cleaned, indexTargetPath);
+    for (const entry of prepared.filter((member) => member.relativePath.endsWith(".md"))) {
+      await writeMarkdownMember(entry.targetUri, entry.content, entry.targetPath);
+    }
+    await ensureDirectory(filesTargetDir, false);
+    for (const entry of prepared.filter((member) => !member.relativePath.endsWith(".md"))) {
+      const priorBytes = await readFileBytesIfExists(entry.targetPath);
+      await ensureDirectory((0, import_node_path3.dirname)(entry.targetPath), false);
+      await (0, import_promises4.writeFile)(entry.targetPath, entry.content, entry.binary ? { mode: 384 } : { encoding: "utf8", mode: 384 });
+      rollbacks.push(async () => {
+        if (priorBytes !== void 0) {
+          await (0, import_promises4.writeFile)(entry.targetPath, priorBytes, { mode: 384 });
+        } else {
+          await (0, import_promises4.rm)(entry.targetPath, { force: true });
+        }
+      });
+    }
+    await ensureDirectory(packRootTargetDir, false);
+    const priorManifest = await readFileBytesIfExists(manifestTargetPath);
+    await (0, import_promises4.writeFile)(manifestTargetPath, packJson.cleaned, { encoding: "utf8", mode: 384 });
+    rollbacks.push(async () => {
+      if (priorManifest !== void 0) {
+        await (0, import_promises4.writeFile)(manifestTargetPath, priorManifest, { mode: 384 });
+      } else {
+        await (0, import_promises4.rm)(manifestTargetPath, { force: true });
+      }
+    });
+    const currentFiles = new Set(prepared.map((entry) => `${filesRelative}/${entry.relativePath}`));
+    const git = await requiredExecutable("git");
+    const tracked = await runCommand(git, ["-C", team.config.worktree, "ls-files", "--", filesRelative], {
+      allowFailure: true
+    });
+    const stalePaths = tracked.exitCode === 0 ? tracked.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !currentFiles.has(line)) : [];
+    for (const stale of stalePaths) {
+      await runCommand(git, ["-C", team.config.worktree, "rm", "-f", "--ignore-unmatch", "--", stale], {
+        allowFailure: true
+      });
+      if (stale.endsWith(".md")) {
+        const staleUri = workfileToVikingUri(config2, team.config, (0, import_node_path3.join)(team.config.worktree, ...stale.split("/")));
+        try {
+          if (await vikingResourceExists(ov, config2, staleUri)) {
+            await removeMemoryUri(config2, ov, staleUri, dryRun, { quiet: true });
+          }
+        } catch (pruneErr) {
+          messages.push(
+            `Warning: could not remove stale OpenViking resource ${staleUri}: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`
+          );
+        }
+      }
+    }
+  } catch (publishErr) {
+    for (const undo of rollbacks.reverse()) {
+      try {
+        await undo();
+      } catch (_cleanupErr) {
+      }
+    }
+    throw publishErr;
+  }
+  const stagedPaths = [
+    indexRelative,
+    manifestRelative,
+    ...prepared.map((entry) => `${filesRelative}/${entry.relativePath}`)
+  ];
+  const message = options.message ?? `share: publish pack ${artifact.agent}/${artifact.name} (${prepared.length} files)`;
+  const gitMessages = await publishShareGitChange(team.config.worktree, stagedPaths, message, {
     dryRun,
     push: options.push
   });
-  return { artifact, gitMessages, messages, sourcePath: resolvedSourcePath, targetPath, targetUri };
+  return {
+    artifact,
+    gitMessages,
+    messages,
+    sourcePath: resolvedManifest,
+    targetPath: indexTargetPath,
+    targetUri: indexTargetUri
+  };
 }
 async function listSharedAgentArtifacts(config2, options = {}) {
   const syncResult = await maybeSyncSharedArtifacts(config2, options);
@@ -37590,6 +37982,10 @@ async function installSharedAgentArtifacts(config2, options) {
   }
   let installedCount = 0;
   for (const artifact of artifacts) {
+    if (isBundleArtifact(artifact)) {
+      installedCount += await installBundleArtifact(artifact, options, dryRun, messages);
+      continue;
+    }
     const label = sharedArtifactLabel(artifact.artifact);
     const state = await sharedArtifactInstallState(artifact);
     if (dryRun) {
@@ -37606,7 +38002,7 @@ async function installSharedAgentArtifacts(config2, options) {
       messages.push(`Already installed ${label}: ${portablePath(artifact.installPath)}`);
       continue;
     }
-    await ensureDirectory((0, import_node_path4.dirname)(artifact.installPath), false);
+    await ensureDirectory((0, import_node_path3.dirname)(artifact.installPath), false);
     await (0, import_promises4.writeFile)(artifact.installPath, state.sourceContent, { encoding: "utf8", mode: 384 });
     await writeSharedArtifactMetadata(artifact, state.sourceSha);
     installedCount += 1;
@@ -37635,10 +38031,10 @@ function normalizeTeamName(input) {
   return candidate;
 }
 function teamsFilePath(config2) {
-  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams.json");
+  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams.json");
 }
 function teamWorktreePath(config2, team) {
-  return (0, import_node_path4.join)(
+  return (0, import_node_path3.join)(
     config2.agentContextHome,
     "data",
     "viking",
@@ -37651,7 +38047,7 @@ function teamWorktreePath(config2, team) {
   );
 }
 function teamGitdirPath(config2, team) {
-  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
+  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
 async function readTeamsFile(config2) {
   const path = teamsFilePath(config2);
@@ -37707,7 +38103,7 @@ async function resolveTeam(config2, requested) {
   return { config: found, name: wantName };
 }
 function workfileToVikingUri(config2, team, filePath) {
-  const rel = (0, import_node_path4.relative)(team.worktree, filePath).split(import_node_path4.sep).join("/");
+  const rel = (0, import_node_path3.relative)(team.worktree, filePath).split(import_node_path3.sep).join("/");
   return `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config2, uri) {
@@ -37765,15 +38161,15 @@ async function isRegularFileNoSymlink(path) {
   }
 }
 function inferShareArtifact(path, options) {
-  const normalizedPath = path.split(import_node_path4.sep).join("/");
-  const fileName = (0, import_node_path4.basename)(path);
+  const normalizedPath = path.split(import_node_path3.sep).join("/");
+  const fileName = (0, import_node_path3.basename)(path);
   const lowerFileName = fileName.toLowerCase();
   const lowerPath = normalizedPath.toLowerCase();
   const inferredKind = lowerFileName === "skill.md" ? "skill" : lowerPath.includes("/.claude/commands/") && lowerFileName.endsWith(".md") ? "command" : void 0;
   const inferredAgent = lowerPath.includes("/.codex/skills/") ? "codex" : lowerPath.includes("/.claude/skills/") || lowerPath.includes("/.claude/commands/") ? "claude" : void 0;
   const extensionIndex = fileName.lastIndexOf(".");
   const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName;
-  const inferredName = lowerFileName === "skill.md" ? (0, import_node_path4.basename)((0, import_node_path4.dirname)(path)) : stem;
+  const inferredName = lowerFileName === "skill.md" ? (0, import_node_path3.basename)((0, import_node_path3.dirname)(path)) : stem;
   const kind = options.kind ?? inferredKind;
   const agent = options.agent ?? inferredAgent;
   const name = options.name ?? inferredName;
@@ -37814,10 +38210,13 @@ function sharedArtifactFromRelativePath(relativePath) {
   if (parts.length === 4 && parts[1] === "commands" && parts[2] === "claude" && parts[3].endsWith(".md")) {
     return { agent: "claude", kind: "command", name: parts[3].slice(0, -".md".length) };
   }
+  if (parts.length === 5 && parts[1] === "packs" && (parts[2] === "codex" || parts[2] === "claude") && parts[4] === `${parts[3]}${PACK_INDEX_SUFFIX}`) {
+    return { agent: parts[2], kind: "pack", name: parts[3] };
+  }
   return void 0;
 }
 async function collectSharedArtifacts(worktree, team) {
-  const root = (0, import_node_path4.join)(worktree, SHAREABLE_ARTIFACT_DIR);
+  const root = (0, import_node_path3.join)(worktree, SHAREABLE_ARTIFACT_DIR);
   if (!await isDirectory(root)) {
     return [];
   }
@@ -37825,7 +38224,7 @@ async function collectSharedArtifacts(worktree, team) {
   async function visit(path) {
     const entries = await (0, import_promises4.readdir)(path, { withFileTypes: true });
     for (const entry of entries) {
-      const full = (0, import_node_path4.join)(path, entry.name);
+      const full = (0, import_node_path3.join)(path, entry.name);
       if (entry.isDirectory()) {
         await visit(full);
         continue;
@@ -37833,23 +38232,100 @@ async function collectSharedArtifacts(worktree, team) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) {
         continue;
       }
-      const relativePath = (0, import_node_path4.relative)(worktree, full).split(import_node_path4.sep).join("/");
+      const relativePath = (0, import_node_path3.relative)(worktree, full).split(import_node_path3.sep).join("/");
       const artifact = sharedArtifactFromRelativePath(relativePath);
       if (artifact === void 0) {
         continue;
       }
-      out.push({
-        artifact,
-        installPath: sharedArtifactInstallPath(team, artifact),
-        sourcePath: full,
-        sourceRelativePath: relativePath,
-        team
-      });
-    }
+      const artifactDir = (0, import_node_path3.dirname)(full);
+      if (artifact.kind === "pack" && !await isFile((0, import_node_path3.join)(artifactDir, `${artifact.name}${PACK_MANIFEST_SUFFIX}`))) {
+        console.warn(
+          `Skipping incomplete shared pack (missing ${artifact.name}${PACK_MANIFEST_SUFFIX}): ${relativePath}`
+        );
+        continue;
+      }
+      try {
+        out.push({
+          artifact,
+          installPath: sharedArtifactInstallPath(team, artifact),
+          members: await collectArtifactMembers(artifact, artifactDir),
+          sourcePath: full,
+          sourceRelativePath: relativePath,
+          team
+        });
+      } catch (err) {
+        console.warn(`Skipping shared artifact ${relativePath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
   }
   await visit(root);
   return out.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
 }
+async function collectArtifactMembers(artifact, artifactDir) {
+  if (artifact.kind === "skill") {
+    return collectSharedBundleMembers(artifactDir);
+  }
+  if (artifact.kind === "pack") {
+    return collectSharedPackMembers(artifact, artifactDir);
+  }
+  return void 0;
+}
+function isContainedMemberPath(baseDir, relativePath) {
+  if ((0, import_node_path3.isAbsolute)(relativePath) || relativePath.split("/").includes("..")) {
+    return false;
+  }
+  const resolved = (0, import_node_path3.join)(baseDir, ...relativePath.split("/"));
+  return resolved === baseDir || resolved.startsWith(baseDir + import_node_path3.sep);
+}
+async function collectSharedPackMembers(artifact, packDir) {
+  const filesDir = (0, import_node_path3.join)(packDir, PACK_FILES_DIR);
+  if (!await isDirectory(filesDir)) {
+    return [];
+  }
+  const manifestRaw = await readFileIfExists((0, import_node_path3.join)(packDir, `${artifact.name}${PACK_MANIFEST_SUFFIX}`));
+  if (manifestRaw !== void 0) {
+    const rawMembers = parseJsonConfigObject(manifestRaw)?.members;
+    if (Array.isArray(rawMembers)) {
+      const fromManifest = [];
+      for (const entry of rawMembers) {
+        const path = entry?.path;
+        if (typeof path === "string" && path.length > 0) {
+          if (!isContainedMemberPath(filesDir, path)) {
+            throw new Error(`Refusing pack member with an unsafe path that escapes the pack root: ${path}`);
+          }
+          fromManifest.push({ absolutePath: (0, import_node_path3.join)(filesDir, ...path.split("/")), relativePath: path });
+        }
+      }
+      if (fromManifest.length > 0) {
+        return fromManifest.sort((a, b) => compareStrings(a.relativePath, b.relativePath));
+      }
+    }
+  }
+  return collectBundleMemberFiles(filesDir);
+}
+async function collectSharedBundleMembers(skillDir) {
+  const manifestRaw = await readFileIfExists((0, import_node_path3.join)(skillDir, BUNDLE_MANIFEST_FILE));
+  if (manifestRaw !== void 0) {
+    const parsed = parseJsonConfigObject(manifestRaw);
+    const rawMembers = parsed?.members;
+    if (Array.isArray(rawMembers)) {
+      const fromManifest = [];
+      for (const entry of rawMembers) {
+        const path = entry?.path;
+        if (typeof path === "string" && path.length > 0) {
+          if (!isContainedMemberPath(skillDir, path)) {
+            throw new Error(`Refusing skill member with an unsafe path that escapes the skill root: ${path}`);
+          }
+          fromManifest.push({ absolutePath: (0, import_node_path3.join)(skillDir, ...path.split("/")), relativePath: path });
+        }
+      }
+      if (fromManifest.length > 0) {
+        return fromManifest.sort((a, b) => compareStrings(a.relativePath, b.relativePath));
+      }
+    }
+  }
+  return collectBundleMemberFiles(skillDir);
+}
 function filterSharedArtifacts(artifacts, options) {
   const name = options.name === void 0 ? void 0 : uriSegment(options.name);
   return artifacts.filter((artifact) => {
@@ -37872,8 +38348,223 @@ async function maybeSyncSharedArtifacts(config2, options) {
   return syncSharedReposBeforeAgentRead(config2);
 }
 async function sharedArtifactInstallStatus(artifact) {
+  if (isBundleArtifact(artifact)) {
+    return sharedBundleInstallStatus(artifact);
+  }
   return (await sharedArtifactInstallState(artifact)).status;
 }
+function bundleInstallRoot(artifact) {
+  return artifact.artifact.kind === "pack" ? artifact.installPath : (0, import_node_path3.dirname)(artifact.installPath);
+}
+function bundleInstallMetadataPath(artifact) {
+  return (0, import_node_path3.join)(bundleInstallRoot(artifact), BUNDLE_INSTALL_METADATA_FILE);
+}
+async function readBundleInstallMetadata(artifact) {
+  const raw = await readFileIfExists(bundleInstallMetadataPath(artifact));
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = parseJsonConfigObject(raw);
+  if (parsed === void 0 || parsed.version !== ARTIFACT_INSTALL_METADATA_VERSION || !Array.isArray(parsed.members)) {
+    return void 0;
+  }
+  const recordedArtifact = parsed.artifact;
+  if (recordedArtifact?.agent !== artifact.artifact.agent || recordedArtifact?.kind !== artifact.artifact.kind || recordedArtifact?.name !== artifact.artifact.name || parsed.team !== artifact.team) {
+    return void 0;
+  }
+  const map3 = /* @__PURE__ */ new Map();
+  for (const entry of parsed.members) {
+    const path = entry?.path;
+    const sourceSha256 = entry?.sourceSha256;
+    const installedSha256 = entry?.installedSha256;
+    if (typeof path === "string" && typeof sourceSha256 === "string" && typeof installedSha256 === "string") {
+      map3.set(path, { installedSha256, sourceSha256 });
+    }
+  }
+  return map3;
+}
+async function sharedBundleInstallStatus(artifact) {
+  const members = artifact.members ?? [];
+  const installRoot = bundleInstallRoot(artifact);
+  const metadata = await readBundleInstallMetadata(artifact);
+  const expanded = await prepareInstallMembers(members, installRoot, artifact.artifact.kind === "pack");
+  const expectedByPath = new Map(expanded.map((entry) => [entry.relativePath, entry]));
+  let installedCount = 0;
+  let localChanged = false;
+  let remoteChanged = false;
+  const memberPaths = /* @__PURE__ */ new Set();
+  for (const member of members) {
+    memberPaths.add(member.relativePath);
+    const expected = expectedByPath.get(member.relativePath);
+    if (expected === void 0) {
+      remoteChanged = true;
+      continue;
+    }
+    const installedBytes = await readFileBytesIfExists((0, import_node_path3.join)(installRoot, ...member.relativePath.split("/")));
+    if (installedBytes === void 0) {
+      remoteChanged = true;
+      continue;
+    }
+    installedCount += 1;
+    const installedSha = sha256(installedBytes);
+    const recorded = metadata?.get(member.relativePath);
+    if (recorded === void 0) {
+      if (installedSha !== expected?.installedSha256) {
+        localChanged = true;
+      }
+      continue;
+    }
+    if (installedSha !== recorded.installedSha256) {
+      localChanged = true;
+    }
+    if (expected?.sourceSha256 !== recorded.sourceSha256) {
+      remoteChanged = true;
+    }
+  }
+  if (metadata !== void 0) {
+    for (const [recordedPath, recorded] of metadata) {
+      if (memberPaths.has(recordedPath)) {
+        continue;
+      }
+      remoteChanged = true;
+      const installedBytes = await readFileBytesIfExists((0, import_node_path3.join)(installRoot, ...recordedPath.split("/")));
+      if (installedBytes !== void 0 && sha256(installedBytes) !== recorded.installedSha256) {
+        localChanged = true;
+      }
+    }
+  }
+  if (installedCount === 0 && metadata === void 0) {
+    return "not_installed";
+  }
+  if (localChanged && remoteChanged) {
+    return "remote_changed_and_local_modified";
+  }
+  if (remoteChanged) {
+    return "update_available";
+  }
+  if (localChanged) {
+    return "local_modified";
+  }
+  return "current";
+}
+function expandPackRoot(text, installRoot) {
+  return text.split(PACK_ROOT_TOKEN).join(installRoot);
+}
+async function prepareInstallMembers(members, installRoot, expandTokens) {
+  const prepared = await Promise.all(
+    members.map(async (member) => {
+      const sourceBytes = await readFileBytesIfExists(member.absolutePath);
+      if (sourceBytes === void 0) {
+        return void 0;
+      }
+      const installedBytes = expandTokens && !isProbablyBinary(sourceBytes) ? Buffer.from(expandPackRoot(sourceBytes.toString("utf8"), installRoot), "utf8") : sourceBytes;
+      return {
+        installedBytes,
+        installedSha256: sha256(installedBytes),
+        relativePath: member.relativePath,
+        sourceSha256: sha256(sourceBytes)
+      };
+    })
+  );
+  return prepared.filter((member) => member !== void 0);
+}
+function serializeInstallMetadata(artifact, prepared) {
+  const metadata = {
+    artifact: artifact.artifact,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    members: prepared.map((entry) => ({
+      installedSha256: entry.installedSha256,
+      path: entry.relativePath,
+      sourceSha256: entry.sourceSha256
+    })).sort((a, b) => compareStrings(a.path, b.path)),
+    team: artifact.team,
+    version: ARTIFACT_INSTALL_METADATA_VERSION
+  };
+  return `${JSON.stringify(metadata, void 0, 2)}
+`;
+}
+async function installBundleArtifact(artifact, options, dryRun, messages) {
+  const members = artifact.members ?? [];
+  const installRoot = bundleInstallRoot(artifact);
+  const kindLabel = artifact.artifact.kind === "pack" ? "pack" : "bundle";
+  const label = `${sharedArtifactLabel(artifact.artifact)} ${kindLabel} (${members.length} files)`;
+  const status = await sharedBundleInstallStatus(artifact);
+  if (dryRun) {
+    const verb = sharedArtifactDryRunVerb(status, options.force === true);
+    const suffix = sharedArtifactDryRunSuffix(status, options.force === true);
+    messages.push(`${verb} ${label}: ${portablePath(installRoot)}${suffix}`);
+    return 0;
+  }
+  if ((status === "local_modified" || status === "remote_changed_and_local_modified") && options.force !== true) {
+    throw new Error(`Refusing to overwrite ${portablePath(installRoot)}. Pass force=true or --force.`);
+  }
+  const prepared = await prepareInstallMembers(members, installRoot, artifact.artifact.kind === "pack");
+  if (prepared.length < members.length && options.force !== true) {
+    throw new Error(
+      `Refusing to install ${portablePath(installRoot)}: ${members.length - prepared.length} declared member(s) are unreadable in the shared pack (the shared worktree may be mid-sync). Retry after sync, or pass force=true / --force.`
+    );
+  }
+  if (status === "current") {
+    await (0, import_promises4.writeFile)(bundleInstallMetadataPath(artifact), serializeInstallMetadata(artifact, prepared), { mode: 384 });
+    messages.push(`Already installed ${label}: ${portablePath(installRoot)}`);
+    await surfacePackRequirements(artifact, messages);
+    return 0;
+  }
+  const stagingRoot = `${installRoot}.threadnote-staging`;
+  await (0, import_promises4.rm)(stagingRoot, { force: true, recursive: true });
+  for (const entry of prepared) {
+    const dest = (0, import_node_path3.join)(stagingRoot, ...entry.relativePath.split("/"));
+    await ensureDirectory((0, import_node_path3.dirname)(dest), false);
+    await (0, import_promises4.writeFile)(dest, entry.installedBytes, { mode: 384 });
+  }
+  await (0, import_promises4.writeFile)((0, import_node_path3.join)(stagingRoot, BUNDLE_INSTALL_METADATA_FILE), serializeInstallMetadata(artifact, prepared), {
+    mode: 384
+  });
+  await ensureDirectory((0, import_node_path3.dirname)(installRoot), false);
+  const backupRoot = `${installRoot}.threadnote-old`;
+  await (0, import_promises4.rm)(backupRoot, { force: true, recursive: true });
+  const hadPriorInstall = await exists(installRoot);
+  if (hadPriorInstall) {
+    await (0, import_promises4.rename)(installRoot, backupRoot);
+  }
+  try {
+    await (0, import_promises4.rename)(stagingRoot, installRoot);
+  } catch (swapErr) {
+    if (hadPriorInstall) {
+      await (0, import_promises4.rename)(backupRoot, installRoot);
+    }
+    throw swapErr;
+  }
+  await (0, import_promises4.rm)(backupRoot, { force: true, recursive: true });
+  messages.push(`${sharedArtifactInstallVerb(status, options.force === true)} ${label}: ${portablePath(installRoot)}`);
+  await surfacePackRequirements(artifact, messages);
+  return 1;
+}
+async function surfacePackRequirements(artifact, messages) {
+  if (artifact.artifact.kind !== "pack") {
+    return;
+  }
+  const raw = await readFileIfExists(
+    (0, import_node_path3.join)((0, import_node_path3.dirname)(artifact.sourcePath), `${artifact.artifact.name}${PACK_MANIFEST_SUFFIX}`)
+  );
+  if (raw === void 0) {
+    return;
+  }
+  const deps = parseJsonConfigObject(raw)?.deps;
+  if (deps === void 0 || typeof deps !== "object") {
+    return;
+  }
+  const stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  const depsRecord = deps;
+  const tooling = [...stringList(depsRecord.runtime), ...stringList(depsRecord.cli), ...stringList(depsRecord.os)];
+  const mcp = stringList(depsRecord.mcp);
+  if (tooling.length > 0) {
+    messages.push(`This pack will NOT run until these exist (Threadnote installs files only): ${tooling.join(", ")}.`);
+  }
+  if (mcp.length > 0) {
+    messages.push(`Configure these MCP server(s) separately: ${mcp.join(", ")}.`);
+  }
+}
 async function sharedArtifactInstallState(artifact) {
   const sourceContent = await (0, import_promises4.readFile)(artifact.sourcePath, "utf8");
   const sourceSha = sha256(sourceContent);
@@ -37944,7 +38635,7 @@ async function writeSharedArtifactMetadata(artifact, sourceSha) {
     version: ARTIFACT_INSTALL_METADATA_VERSION
   };
   const metadataPath = sharedArtifactMetadataPath(artifact);
-  await ensureDirectory((0, import_node_path4.dirname)(metadataPath), false);
+  await ensureDirectory((0, import_node_path3.dirname)(metadataPath), false);
   await (0, import_promises4.writeFile)(metadataPath, `${JSON.stringify(metadata, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
@@ -37996,336 +38687,834 @@ function sharedArtifactLabel(artifact) {
   return `${artifact.kind} ${artifact.agent}/${artifact.name}`;
 }
 function sharedArtifactInstallPath(team, artifact) {
-  if (artifact.kind === "skill" && artifact.agent === "codex") {
-    return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".codex", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  const agentDir = artifact.agent === "codex" ? ".codex" : ".claude";
+  if (artifact.kind === "pack") {
+    return (0, import_node_path3.join)((0, import_node_os2.homedir)(), agentDir, "skills", "threadnote-packs", team, artifact.name);
+  }
+  if (artifact.kind === "skill") {
+    return (0, import_node_path3.join)((0, import_node_os2.homedir)(), agentDir, "skills", "threadnote", team, artifact.name, "SKILL.md");
+  }
+  return (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".claude", "commands", "threadnote", team, `${artifact.name}.md`);
+}
+function stripPersonalProvenance(content) {
+  const lines = content.split("\n");
+  let headerEnd = lines.length;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].trim() === "") {
+      headerEnd = index;
+      break;
+    }
+  }
+  const cleaned = [];
+  for (let index = 0; index < headerEnd; index += 1) {
+    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
+      continue;
+    }
+    cleaned.push(lines[index]);
   }
-  if (artifact.kind === "skill" && artifact.agent === "claude") {
-    return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".claude", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  for (let index = headerEnd; index < lines.length; index += 1) {
+    cleaned.push(lines[index]);
+  }
+  return cleaned.join("\n");
+}
+async function ensureSharedDirectoryChain(config2, ov, memoryUri, dryRun, options = {}) {
+  const directoryUri = parentUri(memoryUri);
+  for (const uri of sharedDirectoryChain(config2, directoryUri)) {
+    const args = withIdentity(config2, ["stat", uri]);
+    if (dryRun) {
+      if (options.quiet !== true) {
+        console.log(`Would run: ${formatShellCommand(ov, args)}`);
+      }
+      continue;
+    }
+    const statResult = await runCommand(ov, args, { allowFailure: true });
+    if (statResult.exitCode === 0) {
+      continue;
+    }
+    if (options.quiet === true) {
+      await runCommand(ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
+    } else {
+      await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
+    }
+  }
+}
+function parentUri(uri) {
+  const lastSlash = uri.lastIndexOf("/");
+  return lastSlash === -1 ? uri : uri.slice(0, lastSlash);
+}
+function sharedDirectoryChain(config2, directoryUri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!directoryUri.startsWith(prefix)) {
+    return [directoryUri];
+  }
+  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 writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, options = {}) {
+  if (dryRun) {
+    const args = withIdentity(config2, [
+      "write",
+      uri,
+      "--from-file",
+      "<staged temp file>",
+      "--mode",
+      initialMode,
+      "--wait",
+      "--timeout",
+      "120"
+    ]);
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    }
+    return;
+  }
+  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path3.join)(stagingDir, "body.txt");
+  try {
+    await (0, import_promises4.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode, options);
+    await refreshMemoryIndex(config2, ov, uri, options);
+  } finally {
+    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
+  }
+}
+var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
+async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, options = {}) {
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
+  const existedBeforeWrite = await vikingResourceExists(ov, config2, uri);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config2, uri);
+    const ourWriteLanded = existsNow && !existedBeforeWrite;
+    const mode = attempt === 0 ? initialMode : ourWriteLanded ? "replace" : initialMode;
+    const args = withIdentity(config2, [
+      "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, config2, 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, config2, 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, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
+  }
+}
+async function refreshMemoryIndex(config2, ov, uri, options = {}) {
+  const result = await runCommand(
+    ov,
+    withIdentity(config2, ["reindex", uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
+    { 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 (options.quiet !== true) {
+    console.error(
+      `Memory stored, but index refresh failed for ${uri}: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+  }
+}
+async function waitForOvQueue(ov, config2, options = {}) {
+  const result = await runCommand(ov, withIdentity(config2, ["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());
+  }
+}
+function isTransientOvFailure(stderr, stdout2) {
+  const output = `${stderr}
+${stdout2}`.toLowerCase();
+  return output.includes("resource is busy") || output.includes("resource is being processed") || output.includes("network error") || output.includes("error sending request") || output.includes("http request failed") || output.includes("connection refused") || output.includes("connection reset") || output.includes("timed out");
+}
+function isResourceBusyFailure(stderr, stdout2) {
+  const output = `${stderr}
+${stdout2}`.toLowerCase();
+  return output.includes("resource is busy") || output.includes("resource is being processed");
+}
+async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
+  const content = await (0, import_promises4.readFile)(filePath, "utf8");
+  await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
+}
+async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
+  const args = withIdentity(config2, ["rm", uri]);
+  if (dryRun) {
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    }
+    return;
+  }
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
+  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, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
+  }
+}
+async function vikingResourceExists(ov, config2, uri) {
+  const result = await runCommand(ov, withIdentity(config2, ["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;
+  }
+  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) {
+    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_path3.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path3.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_path3.join)(worktree, rel), relativePath: rel, status });
+    }
+    index += 2;
+  }
+  return changes;
+}
+async function applyChangesToOpenViking(config2, team, changes, options = {}) {
+  const ov = await openVikingCliForMode(false);
+  const failed = [];
+  for (const change of changes) {
+    if (!change.relativePath.endsWith(".md")) {
+      continue;
+    }
+    const firstSegment = change.relativePath.split("/")[0];
+    if (!SHAREABLE_TOP_LEVEL_DIRS.includes(firstSegment)) {
+      continue;
+    }
+    const uri = workfileToVikingUri(config2, team, change.path);
+    try {
+      if (change.status === "removed") {
+        await removeMemoryUri(config2, ov, uri, false, options);
+        continue;
+      }
+      if (!await isFile(change.path)) {
+        continue;
+      }
+      const ovHasResource = await vikingResourceExists(ov, config2, 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(config2, ov, uri, false, options);
+      const writeMode = ovHasResource ? "replace" : "create";
+      await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.quiet !== true) {
+        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
+      }
+      failed.push(change);
+    }
+  }
+  return { failed };
+}
+function mergeChanges(...lists) {
+  const map3 = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const change of list) {
+      map3.set(change.relativePath, change);
+    }
+  }
+  return [...map3.values()];
+}
+async function applyAndPersistChanges(config2, team, state, changes, options = {}) {
+  if (changes.length === 0) {
+    return { failed: [] };
+  }
+  state.pendingReindexes.set(team.name, changes);
+  await writePendingReindexes(config2, state);
+  const result = await applyChangesToOpenViking(config2, team, changes, options);
+  if (result.failed.length > 0) {
+    state.pendingReindexes.set(team.name, result.failed);
+  } else {
+    state.pendingReindexes.delete(team.name);
+  }
+  await writePendingReindexes(config2, state);
+  return result;
+}
+
+// src/onboarding.ts
+async function gatherOnboardingContext(config2) {
+  return { seededProjects: await safeSeededProjects(config2), teams: await safeTeams(config2) };
+}
+async function safeTeams(config2) {
+  try {
+    return Object.keys((await readTeamsFile(config2)).teams ?? {}).sort();
+  } catch (_err) {
+    return [];
+  }
+}
+async function safeSeededProjects(config2) {
+  try {
+    return (await readSeedManifest(config2.manifestPath)).projects.map((project) => project.name);
+  } catch (_err) {
+    return [];
+  }
+}
+function buildOnboardingGuide(state) {
+  const serverLine = state.serverUp === false ? "OpenViking is NOT responding \u2014 recall/remember will fail until the user runs `threadnote start`. Offer to walk them through that first." : state.serverUp === true ? "OpenViking is running." : "OpenViking status unknown \u2014 if recall/remember return connection errors, the fix is `threadnote start`.";
+  const teamLine = state.teams.length > 0 ? `Team sharing is configured: ${state.teams.join(", ")}. They can publish memories and skills to teammates.` : "No share team configured yet \u2014 team sharing is available but needs a one-time `threadnote share init <git-remote>`.";
+  const seedLine = state.seededProjects.length > 0 ? `Seeded project guidance is available for: ${state.seededProjects.join(", ")} (recall surfaces it when the query names the project).` : "No seeded project guidance yet \u2014 recall draws on personal memories and shared team memories.";
+  const hasTeam = state.teams.length > 0;
+  return [
+    "# Threadnote \u2014 what you can do here",
+    "",
+    "You are onboarding the user to Threadnote. Do NOT paste this list verbatim. Read it,",
+    "then guide the user conversationally: lead with what is most useful given the state",
+    "below, explain one capability in a sentence, and OFFER to run it for them (with their",
+    "go-ahead) instead of only describing it. Start small.",
+    "",
+    "## Current setup",
+    `- ${serverLine}`,
+    `- ${teamLine}`,
+    `- ${seedLine}`,
+    "",
+    "## Capabilities to offer",
+    "",
+    "Recall context \u2014 pull back the last handoff and durable knowledge for the current",
+    "repo+branch before starting work, so the session continues where the last one left off.",
+    '  Run: recall_context({"query":"<repo> latest handoff","callerCwd":"<abs cwd>"}), then',
+    "  read_context the most relevant viking:// URI it returns.",
+    "",
+    "Capture work \u2014 save a durable fact (a decision, interface, gotcha) or a handoff (current",
+    "status + next step) so the next session or a teammate inherits it.",
+    '  Run: remember_context({"text":"...","kind":"durable","project":"<repo>","topic":"<feature>"})',
+    '  or a handoff with kind:"handoff". Reuse the same project/topic to keep one memory current.',
+    "",
+    "Tidy memory \u2014 when recall surfaces overlapping notes for one topic, preview a scoped merge.",
+    '  Run: compact_context({"project":"<repo>","topic":"<topic>","dryRun":true}) and review before applying.',
+    "",
+    "Share with your team \u2014 publish a durable memory teammates\u2019 agents can recall. Secrets are",
+    "scrubbed/blocked; handoffs/preferences/local-path notes are never shared.",
+    hasTeam ? '  Run: share_publish({"uri":"viking://user/<you>/memories/durable/projects/<p>/<m>.md"}).' : '  First (one-time): `threadnote share init git@github.com:org/team-memories.git`, then share_publish({"uri":"..."}).',
+    "",
+    "Share skills & packs \u2014 publish a Codex/Claude skill, or a multi-skill pack (skills + shared",
+    "scripts), into the team catalog; teammates install them on demand.",
+    '  Run: share_skill({"path":"~/.claude/skills/<name>/SKILL.md"}) or',
+    '  share_bundle({"path":"<repo>/threadnote-bundle.json"}). Teammates: list_shared_skills({})',
+    '  then install_shared_skill({"name":"<name>"}).',
+    "",
+    "Setup & health \u2014 verify the local install and server.",
+    state.serverUp === false ? "  Run: `threadnote start` to bring OpenViking up." : "  Run: `threadnote doctor` to check prerequisites.",
+    "",
+    "## How to proceed",
+    "Pick the single most useful step for right now given the setup above (if the server is",
+    "down, that first; otherwise a recall for the current repo is the usual starting point),",
+    "describe it in one sentence, and ask whether to run it. Then chain into the others as the",
+    "user shows interest. Keep it interactive \u2014 one offer at a time, not a wall of options."
+  ].join("\n");
+}
+
+// src/memory_hygiene.ts
+var import_node_path4 = require("node:path");
+var HYGIENE_SOURCES_HEADING = "## Threadnote Hygiene Sources";
+var STALE_HANDOFF_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function parseMemoryDocument(uri, content) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const separatorIndex = trimmed.indexOf("\n\n");
+  const header = separatorIndex === -1 ? trimmed : trimmed.slice(0, separatorIndex);
+  const body = separatorIndex === -1 ? "" : trimmed.slice(separatorIndex + 2).trim();
+  const firstLine = header.split("\n")[0]?.trim();
+  if (firstLine !== "MEMORY" && firstLine !== "HANDOFF") {
+    return void 0;
+  }
+  const kind = parseOptionalMemoryKind(headerValue(header, "kind")) ?? (firstLine === "HANDOFF" ? "handoff" : void 0);
+  const status = parseOptionalMemoryStatus(headerValue(header, "status")) ?? "active";
+  if (!kind) {
+    return void 0;
+  }
+  return {
+    body,
+    content: trimmed,
+    headerTitle: firstLine,
+    metadata: {
+      archivedFrom: headerValue(header, "archived_from"),
+      kind,
+      project: normalizeOptionalMetadata(headerValue(header, "project") ?? headerValue(header, "repo")),
+      sourceAgentClient: headerValue(header, "source_agent_client") ?? "unknown",
+      status,
+      supersedes: headerValue(header, "supersedes"),
+      timestamp: headerValue(header, "timestamp") ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      topic: normalizeOptionalMetadata(headerValue(header, "topic"))
+    },
+    uri
+  };
+}
+function buildCompactPlan(records, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const groupedRecords = records.map((record2) => groupableRecord(record2)).filter((item) => item !== void 0).filter((item) => item.project === options.project).filter((item) => options.topic === void 0 || item.topic === options.topic).filter((item) => options.kind === void 0 || item.record.metadata.kind === options.kind);
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of groupedRecords) {
+    groups.set(item.groupKey, [...groups.get(item.groupKey) ?? [], item]);
+  }
+  const keepUpdates = [];
+  const archives = [];
+  const forgets = [];
+  const manualReview = [];
+  for (const group of [...groups.values()].sort(compareGroupedRecordLists)) {
+    const recordsInGroup = group.map((item) => item.record);
+    const kind = recordsInGroup[0]?.metadata.kind;
+    const topic = group[0]?.topic;
+    const project = group[0]?.project;
+    if (!kind || !project || !isCompactableKind(kind)) {
+      continue;
+    }
+    const duplicateGroups = groupBy(recordsInGroup, (record2) => comparableMemoryBody(record2.body));
+    const duplicateForgetUris = /* @__PURE__ */ new Set();
+    const distinctBodyCount = duplicateGroups.size;
+    for (const duplicateGroup of duplicateGroups.values()) {
+      if (duplicateGroup.length < 2) {
+        continue;
+      }
+      const duplicateKeep = preferredKeepRecord(duplicateGroup, topic);
+      for (const duplicate of sortedNewestFirst(duplicateGroup).filter((record2) => record2.uri !== duplicateKeep.uri)) {
+        duplicateForgetUris.add(duplicate.uri);
+        forgets.push({ reason: `exact duplicate of ${duplicateKeep.uri}`, uri: duplicate.uri });
+      }
+      if (distinctBodyCount === 1 || kind !== "handoff") {
+        keepUpdates.push({
+          content: memoryContentWithHygieneSources(
+            duplicateKeep,
+            duplicateGroup.map((record2) => record2.uri)
+          ),
+          reason: "keep exact duplicate group with source URIs",
+          sourceUris: duplicateGroup.map((record2) => record2.uri),
+          uri: duplicateKeep.uri
+        });
+      }
+    }
+    const remainingRecords = recordsInGroup.filter((record2) => !duplicateForgetUris.has(record2.uri));
+    if (recordsInGroup.length > 1 && distinctBodyCount === 1) {
+      continue;
+    }
+    if (remainingRecords.length === 0) {
+      continue;
+    }
+    if (remainingRecords.length === 1) {
+      const [record2] = remainingRecords;
+      if (!record2) {
+        continue;
+      }
+      if (record2.metadata.supersedes === record2.uri) {
+        keepUpdates.push({
+          content: memoryContentWithHygieneSources(record2, [record2.uri]),
+          reason: "strip self-supersedes header",
+          sourceUris: [record2.uri],
+          uri: record2.uri
+        });
+      }
+      if (isStaleLookingHandoff(record2, now)) {
+        manualReview.push({ reason: "stale-looking active handoff", uri: record2.uri });
+      }
+      continue;
+    }
+    if (kind === "handoff") {
+      const keep = preferredKeepRecord(remainingRecords, topic);
+      const sourceUris = recordsInGroup.map((record2) => record2.uri);
+      keepUpdates.push({
+        content: memoryContentWithHygieneSources(keep, sourceUris),
+        reason: "keep latest handoff and preserve source URIs",
+        sourceUris,
+        uri: keep.uri
+      });
+      for (const record2 of sortedNewestFirst(remainingRecords).filter((item) => item.uri !== keep.uri)) {
+        archives.push({
+          kind,
+          project,
+          reason: `older handoff for ${project}/${topic ?? "unknown"}`,
+          topic,
+          uri: record2.uri
+        });
+      }
+      continue;
+    }
+    for (const record2 of sortedNewestFirst(remainingRecords)) {
+      manualReview.push({ reason: `non-exact ${kind} memory in overlapping group`, uri: record2.uri });
+    }
+  }
+  return {
+    archives: dedupeByUri(archives),
+    forgets: dedupeByUri(forgets),
+    keepUpdates: dedupeByUri(keepUpdates),
+    manualReview: dedupeByUri(manualReview),
+    options,
+    recordsScanned: groupedRecords.length
+  };
+}
+function memoryContentWithHygieneSources(record2, sourceUris) {
+  const body = stripHygieneSources(record2.body);
+  const uniqueSourceUris = [...new Set(sourceUris)].sort();
+  const metadata = {
+    ...record2.metadata,
+    supersedes: record2.metadata.supersedes === record2.uri ? void 0 : record2.metadata.supersedes
+  };
+  return formatMemoryDocument(
+    record2.headerTitle,
+    metadata,
+    [body, "", HYGIENE_SOURCES_HEADING, "", ...uniqueSourceUris.map((uri) => `- ${uri}`)].join("\n")
+  );
+}
+function formatCompactPlan(plan, options) {
+  const scope = [
+    `project ${plan.options.project}`,
+    plan.options.topic ? `topic ${plan.options.topic}` : void 0,
+    plan.options.kind ? `kind ${plan.options.kind}` : void 0
+  ].filter((item) => item !== void 0).join(", ");
+  const lines = [
+    `${options.apply ? "Applying" : "Dry-run"} memory hygiene plan for ${scope}`,
+    `Records scanned: ${plan.recordsScanned}`,
+    "",
+    formatPlanSection(
+      "Keep/update",
+      plan.keepUpdates.map((action) => `${action.uri} (${action.reason}; sources: ${action.sourceUris.length})`)
+    ),
+    formatPlanSection(
+      "Archive old handoffs",
+      plan.archives.map((action) => `${action.uri} (${action.reason})`)
+    ),
+    formatPlanSection(
+      "Forget exact duplicates",
+      plan.forgets.map((action) => `${action.uri} (${action.reason})`)
+    ),
+    formatPlanSection(
+      "Manual review",
+      plan.manualReview.map((item) => `${item.uri} (${item.reason})`)
+    )
+  ];
+  if (!options.apply) {
+    lines.push("", "No changes made. Re-run with --apply to execute this plan.");
   }
-  return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".claude", "commands", "threadnote", team, `${artifact.name}.md`);
+  return lines.join("\n");
 }
-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;
+function recallHygieneNudges(text, options) {
+  const activeUris = activePersonalMemoryUrisFromText(text, options.user);
+  const nudges = [];
+  const returnedUriSet = new Set(activeUris);
+  const returnedRecords = options.records?.filter((record2) => returnedUriSet.has(record2.uri)).map((record2) => groupableRecord(record2)) ?? [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of returnedRecords) {
+    if (!item) {
+      continue;
     }
+    groups.set(item.groupKey, [...groups.get(item.groupKey) ?? [], item]);
   }
-  const cleaned = [];
-  for (let index = 0; index < headerEnd; index += 1) {
-    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
+  for (const group of [...groups.values()].sort(compareGroupedRecordLists)) {
+    if (group.length < 3) {
       continue;
     }
-    cleaned.push(lines[index]);
-  }
-  for (let index = headerEnd; index < lines.length; index += 1) {
-    cleaned.push(lines[index]);
-  }
-  return cleaned.join("\n");
-}
-async function ensureSharedDirectoryChain(config2, ov, memoryUri, dryRun, options = {}) {
-  const directoryUri = parentUri(memoryUri);
-  for (const uri of sharedDirectoryChain(config2, directoryUri)) {
-    const args = withIdentity(config2, ["stat", uri]);
-    if (dryRun) {
-      if (options.quiet !== true) {
-        console.log(`Would run: ${formatShellCommand(ov, args)}`);
-      }
+    const first = group[0];
+    if (!first || !isCompactableKind(first.record.metadata.kind)) {
       continue;
     }
-    const statResult = await runCommand(ov, args, { allowFailure: true });
-    if (statResult.exitCode === 0) {
+    const topic = first.topic;
+    if (!topic) {
       continue;
     }
-    if (options.quiet === true) {
-      await runCommand(ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
-    } else {
-      await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
+    nudges.push(
+      `${group.length} active ${memoryKindPlural(first.record.metadata.kind)} look overlapping for ${first.project}/${topic}; run compact_context({"project":"${first.project}","topic":"${topic}","dryRun":true}).`
+    );
+  }
+  const projectCounts = /* @__PURE__ */ new Map();
+  for (const uri of activeUris) {
+    const parsed = parsePersonalMemoryUri(uri, options.user);
+    if (!parsed || parsed.kind !== "handoff" || parsed.status !== "active") {
+      continue;
+    }
+    projectCounts.set(parsed.project, (projectCounts.get(parsed.project) ?? 0) + 1);
+  }
+  for (const [project, count] of [...projectCounts.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    if (count < 10) {
+      continue;
     }
+    nudges.push(
+      `Many active handoffs surfaced for ${project}; run compact_context({"project":"${project}","dryRun":true}).`
+    );
   }
+  return [...new Set(nudges)];
 }
-function parentUri(uri) {
-  const lastSlash = uri.lastIndexOf("/");
-  return lastSlash === -1 ? uri : uri.slice(0, lastSlash);
+function activePersonalMemoryUrisFromText(text, user) {
+  const userSegment = uriSegment(user);
+  const matches = text.matchAll(/viking:\/\/[^\s)]+/g);
+  const uris = [];
+  for (const match of matches) {
+    const uri = match[0]?.replace(/[.,;:]+$/g, "");
+    if (!uri || !parsePersonalMemoryUri(uri, userSegment)) {
+      continue;
+    }
+    uris.push(uri);
+  }
+  return [...new Set(uris)];
 }
-function sharedDirectoryChain(config2, directoryUri) {
-  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
-  if (!directoryUri.startsWith(prefix)) {
-    return [directoryUri];
+function parsePersonalMemoryUri(uri, user) {
+  const prefix = `viking://user/${uriSegment(user)}/memories/`;
+  if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
+    return void 0;
   }
-  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 rest = uri.slice(prefix.length);
+  const parts = rest.split("/").filter(Boolean);
+  if (parts.length < 4) {
+    return void 0;
   }
-  return chain;
-}
-async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, options = {}) {
-  if (dryRun) {
-    const args = withIdentity(config2, [
-      "write",
-      uri,
-      "--from-file",
-      "<staged temp file>",
-      "--mode",
-      initialMode,
-      "--wait",
-      "--timeout",
-      "120"
-    ]);
-    if (options.quiet !== true) {
-      console.log(`Would run: ${formatShellCommand(ov, args)}`);
-    }
-    return;
+  if (parts[0] === "handoffs" && parts[1] === "active" && parts[2] && parts[3]?.endsWith(".md")) {
+    return { kind: "handoff", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
   }
-  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path4.join)((0, import_node_os2.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(config2, ov, uri, tempPath, initialMode, options);
-    await refreshMemoryIndex(config2, ov, uri, options);
-  } finally {
-    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
+  if (parts[0] === "durable" && parts[1] === "projects" && parts[2] && parts[3]?.endsWith(".md")) {
+    return { kind: "durable", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
+  }
+  if (parts[0] === "incidents" && parts[1] === "active" && parts[2] && parts[3]?.endsWith(".md")) {
+    return { kind: "incident", project: parts[2], status: "active", topic: parts[3].replace(/\.md$/, "") };
   }
+  return void 0;
 }
-var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
-async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, options = {}) {
-  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
-  const existedBeforeWrite = await vikingResourceExists(ov, config2, uri);
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config2, uri);
-    const ourWriteLanded = existsNow && !existedBeforeWrite;
-    const mode = attempt === 0 ? initialMode : ourWriteLanded ? "replace" : initialMode;
-    const args = withIdentity(config2, [
-      "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, config2, 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, config2, 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, config2, options);
-      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
-    } else {
-      await sleep(1e3 * (attempt + 1));
-    }
+function groupableRecord(record2) {
+  if (record2.metadata.status !== "active" || !isCompactableKind(record2.metadata.kind)) {
+    return void 0;
   }
+  const project = normalizeOptionalMetadata(record2.metadata.project) ?? parseProjectFromUri(record2.uri);
+  if (!project) {
+    return void 0;
+  }
+  const topic = topicForRecord(record2);
+  const groupKey = [record2.metadata.kind, project, topic ?? record2.uri].join("\0");
+  return { groupKey, project, record: record2, topic };
 }
-async function refreshMemoryIndex(config2, ov, uri, options = {}) {
-  const result = await runCommand(
-    ov,
-    withIdentity(config2, ["reindex", uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
-    { 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;
+function topicForRecord(record2) {
+  return normalizeOptionalMetadata(record2.metadata.topic) ?? normalizeOptionalMetadata(branchFromBody(record2.body)) ?? topicFromUri(record2.uri);
+}
+function branchFromBody(body) {
+  const branch = /^branch:\s*(.+)$/m.exec(body)?.[1]?.trim();
+  return branch?.split(/\s+/)[0]?.replace(/[.,;:]+$/g, "");
+}
+function topicFromUri(uri) {
+  const name = (0, import_node_path4.basename)(uri).replace(/\.md$/, "");
+  return name.startsWith("threadnote-") ? void 0 : name;
+}
+function parseProjectFromUri(uri) {
+  const parts = uri.split("/memories/")[1]?.split("/").filter(Boolean) ?? [];
+  if ((parts[0] === "handoffs" || parts[0] === "incidents") && parts[1] === "active") {
+    return parts[2];
   }
-  if (options.quiet !== true) {
-    console.error(
-      `Memory stored, but index refresh failed for ${uri}: ${result.stderr.trim() || result.stdout.trim()}`
-    );
+  if (parts[0] === "durable" && parts[1] === "projects") {
+    return parts[2];
   }
+  return void 0;
 }
-async function waitForOvQueue(ov, config2, options = {}) {
-  const result = await runCommand(ov, withIdentity(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
-  if (options.quiet !== true && result.stdout.trim()) {
-    console.log(result.stdout.trim());
+function comparableMemoryBody(body) {
+  return stripHygieneSources(body).trim().replace(/\s+/g, " ");
+}
+function stripHygieneSources(body) {
+  const index = body.indexOf(`
+${HYGIENE_SOURCES_HEADING}`);
+  if (index !== -1) {
+    return body.slice(0, index).trim();
+  }
+  return body.startsWith(HYGIENE_SOURCES_HEADING) ? "" : body.trim();
+}
+function preferredKeepRecord(records, topic) {
+  const stableRecords = records.filter((record2) => isStableRecord(record2, topic));
+  return sortedNewestFirst(stableRecords.length > 0 ? stableRecords : records)[0] ?? records[0];
+}
+function isStableRecord(record2, topic) {
+  const recordTopic = topic ?? topicForRecord(record2);
+  return recordTopic !== void 0 && (0, import_node_path4.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
+}
+function sortedNewestFirst(records) {
+  return [...records].sort((left, right) => {
+    const timestampDiff = timestampMs(right) - timestampMs(left);
+    return timestampDiff === 0 ? left.uri.localeCompare(right.uri) : timestampDiff;
+  });
+}
+function timestampMs(record2) {
+  const parsed = Date.parse(record2.metadata.timestamp);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function isStaleLookingHandoff(record2, now) {
+  if (record2.metadata.kind !== "handoff") {
+    return false;
   }
-  if (options.quiet !== true && result.stderr.trim()) {
-    console.error(result.stderr.trim());
+  if (now.getTime() - timestampMs(record2) < STALE_HANDOFF_AGE_MS) {
+    return false;
   }
+  return /\b(?:PR|pull request)\s+(?:OPEN|open|is open)|awaiting review|waiting for review|next steps?:\s*address PR review/i.test(
+    record2.body
+  );
 }
-function isTransientOvFailure(stderr, stdout2) {
-  const output = `${stderr}
-${stdout2}`.toLowerCase();
-  return output.includes("resource is busy") || output.includes("resource is being processed") || output.includes("network error") || output.includes("error sending request") || output.includes("http request failed") || output.includes("connection refused") || output.includes("connection reset") || output.includes("timed out");
-}
-function isResourceBusyFailure(stderr, stdout2) {
-  const output = `${stderr}
-${stdout2}`.toLowerCase();
-  return output.includes("resource is busy") || output.includes("resource is being processed");
+function groupBy(values, keyForValue) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = keyForValue(value);
+    groups.set(key, [...groups.get(key) ?? [], value]);
+  }
+  return groups;
 }
-async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
-  const content = await (0, import_promises4.readFile)(filePath, "utf8");
-  await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
+function compareGroupedRecordLists(left, right) {
+  return (left[0]?.groupKey ?? "").localeCompare(right[0]?.groupKey ?? "");
 }
-async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
-  const args = withIdentity(config2, ["rm", uri]);
-  if (dryRun) {
-    if (options.quiet !== true) {
-      console.log(`Would run: ${formatShellCommand(ov, args)}`);
-    }
-    return;
-  }
-  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
-  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, config2, options);
-      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
-    } else {
-      await sleep(1e3 * (attempt + 1));
+function dedupeByUri(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of items) {
+    if (seen.has(item.uri)) {
+      continue;
     }
+    seen.add(item.uri);
+    result.push(item);
   }
+  return result;
 }
-async function vikingResourceExists(ov, config2, uri) {
-  const result = await runCommand(ov, withIdentity(config2, ["stat", uri]), { allowFailure: true });
-  return result.exitCode === 0;
+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");
 }
-async function hasUncommittedChanges(worktree) {
-  const result = await runCommand("git", ["-C", worktree, "status", "--porcelain"], { allowFailure: true });
-  return result.stdout.trim().length > 0;
+function headerValue(header, key) {
+  const prefix = `${key}:`;
+  return header.split("\n").find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
 }
-async function gitOutput(worktree, args, dryRun) {
-  if (dryRun) {
+function parseOptionalMemoryKind(value) {
+  if (!value) {
     return void 0;
   }
-  const result = await runCommand("git", ["-C", worktree, ...args], { allowFailure: true });
-  if (result.exitCode !== 0) {
-    return void 0;
+  if (["durable", "handoff", "incident", "preference", "smoke"].includes(value)) {
+    return value;
   }
-  return result.stdout.trim();
+  return void 0;
 }
-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 [];
+function parseOptionalMemoryStatus(value) {
+  if (!value) {
+    return void 0;
   }
-  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;
+  if (["active", "archived", "superseded"].includes(value)) {
+    return value;
   }
-  return changes;
+  return void 0;
 }
-async function applyChangesToOpenViking(config2, team, changes, options = {}) {
-  const ov = await openVikingCliForMode(false);
-  const failed = [];
-  for (const change of changes) {
-    if (!change.relativePath.endsWith(".md")) {
-      continue;
-    }
-    const firstSegment = change.relativePath.split("/")[0];
-    if (!SHAREABLE_TOP_LEVEL_DIRS.includes(firstSegment)) {
-      continue;
-    }
-    const uri = workfileToVikingUri(config2, team, change.path);
-    try {
-      if (change.status === "removed") {
-        await removeMemoryUri(config2, ov, uri, false, options);
-        continue;
-      }
-      if (!await isFile(change.path)) {
-        continue;
-      }
-      const ovHasResource = await vikingResourceExists(ov, config2, 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(config2, ov, uri, false, options);
-      const writeMode = ovHasResource ? "replace" : "create";
-      await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (options.quiet !== true) {
-        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
-      }
-      failed.push(change);
-    }
-  }
-  return { failed };
+function normalizeOptionalMetadata(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
 }
-function mergeChanges(...lists) {
-  const map3 = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    for (const change of list) {
-      map3.set(change.relativePath, change);
-    }
-  }
-  return [...map3.values()];
+function isCompactableKind(kind) {
+  return kind === "durable" || kind === "handoff" || kind === "incident";
 }
-async function applyAndPersistChanges(config2, team, state, changes, options = {}) {
-  if (changes.length === 0) {
-    return { failed: [] };
+function memoryKindPlural(kind) {
+  switch (kind) {
+    case "handoff":
+      return "handoffs";
+    case "incident":
+      return "incidents";
+    case "durable":
+      return "durable memories";
+    case "preference":
+      return "preferences";
+    case "smoke":
+      return "smoke memories";
   }
-  state.pendingReindexes.set(team.name, changes);
-  await writePendingReindexes(config2, state);
-  const result = await applyChangesToOpenViking(config2, team, changes, options);
-  if (result.failed.length > 0) {
-    state.pendingReindexes.set(team.name, result.failed);
-  } else {
-    state.pendingReindexes.delete(team.name);
+}
+function formatPlanSection(title, lines) {
+  if (lines.length === 0) {
+    return `${title}:
+- none`;
   }
-  await writePendingReindexes(config2, state);
-  return result;
+  return [`${title}:`, ...lines.map((line) => `- ${line}`)].join("\n");
 }
 
 // src/mcp_server.ts
@@ -38408,6 +39597,15 @@ function registerTools(server, config2) {
   );
   registerArchiveTool(server, config2, "archive", "Compatibility alias for archive_context.");
   registerCompactTool(server, config2);
+  server.registerTool(
+    "threadnote_guide",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Onboard the user to Threadnote. Call this when the user asks what they can do with Threadnote, how to get started, for a feature tour/overview, or how Threadnote works \u2014 anything exploratory about Threadnote's capabilities. Returns a state-aware walkthrough (tailored to the user's server health, configured share teams, and seeded projects) written as guidance for YOU to present conversationally and offer to run step by step, not a message to paste. Prefer calling this over describing Threadnote from memory, so the guidance matches the user's actual setup. Takes no arguments.",
+      inputSchema: {}
+    },
+    async () => runThreadnoteGuideTool(config2)
+  );
   server.registerTool(
     "forget",
     {
@@ -38457,14 +39655,14 @@ function registerTools(server, config2) {
     "grep",
     {
       annotations: { readOnlyHint: true, destructiveHint: false },
-      description: "Run exact text search in OpenViking.",
+      description: "Run exact text search in OpenViking. Defaults to your memories subtree when uri is omitted (OpenViking grep requires a scope).",
       inputSchema: {
         caseInsensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
         case_insensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
         nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
         node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
         pattern: external_exports.string().optional().describe("Required text or regex pattern"),
-        uri: external_exports.string().optional().describe("Optional viking:// subtree")
+        uri: external_exports.string().optional().describe("Optional viking:// subtree (defaults to your memories root)")
       }
     },
     async ({ caseInsensitive, case_insensitive, nodeLimit, node_limit, pattern, uri }) => {
@@ -38480,7 +39678,7 @@ function registerTools(server, config2) {
         case_insensitive: caseInsensitive ?? case_insensitive,
         node_limit: nodeLimit ?? node_limit,
         pattern: checkedPattern.value,
-        uri: checkedUri.value
+        uri: checkedUri.value ?? `viking://user/${uriSegment2(config2.user)}/memories`
       });
     }
   );
@@ -38554,9 +39752,10 @@ function registerTools(server, config2) {
     "share_skill",
     {
       annotations: { readOnlyHint: false, destructiveHint: true },
-      description: "Publish a local Codex/Claude skill or Claude command markdown file into a team's shared artifact catalog. Path inference handles ~/.codex/skills/**/SKILL.md, ~/.claude/skills/**/SKILL.md, and ~/.claude/commands/**/*.md; pass agent/kind/name when sharing from another path. Default team is used unless team is provided. Pass preview=true to inspect bytes without writing or committing.",
+      description: "Publish a local Codex/Claude skill or Claude command markdown file into a team's shared artifact catalog. Path inference handles ~/.codex/skills/**/SKILL.md, ~/.claude/skills/**/SKILL.md, and ~/.claude/commands/**/*.md; pass agent/kind/name when sharing from another path. A skill is shared as its whole directory: companion files (scripts, references, assets) beside the SKILL.md travel with it. Default team is used unless team is provided. Pass preview=true to inspect what would land without writing or committing.",
       inputSchema: {
         agent: external_exports.enum(["codex", "claude"]).optional().describe("Agent owner when path inference is ambiguous"),
+        allowBinary: external_exports.boolean().optional().describe("Include binary skill files (unscannable by the scrubber); blocked by default"),
         force: external_exports.boolean().optional().describe("Replace an existing shared artifact with different content"),
         kind: external_exports.enum(["skill", "command"]).optional().describe("Artifact kind when path inference is ambiguous"),
         message: external_exports.string().optional().describe('Commit message override; defaults to "share: publish <path>"'),
@@ -38568,7 +39767,7 @@ function registerTools(server, config2) {
         team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
       }
     },
-    async ({ agent, force, kind, message, name, path, preview, push, redact, team }) => {
+    async ({ agent, allowBinary, force, kind, message, name, path, preview, push, redact, team }) => {
       const checkedPath = requiredText(path, "share_skill", "path", {
         path: "~/.codex/skills/example/SKILL.md"
       });
@@ -38577,6 +39776,7 @@ function registerTools(server, config2) {
       }
       return runShareSkillTool(config2, checkedPath.value, {
         agent,
+        allowBinary,
         force,
         kind,
         message,
@@ -38588,14 +39788,40 @@ function registerTools(server, config2) {
       });
     }
   );
+  server.registerTool(
+    "share_bundle",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Publish a multi-skill constellation (pack) into a team's shared artifact catalog from a threadnote-bundle.json manifest. Use this when several skills share code that lives outside any single skill directory (e.g. repo-root scripts/lib). The manifest declares name, agent, skills, include paths, external deps, and pathRewrites. Hardcoded repo-root paths are rewritten to a portable token and expanded on install. Pass preview=true to inspect what would land without writing or committing.",
+      inputSchema: {
+        allowBinary: external_exports.boolean().optional().describe("Include binary files (unscannable by the scrubber); blocked by default"),
+        force: external_exports.boolean().optional().describe("Replace existing shared pack files with different content"),
+        message: external_exports.string().optional().describe("Commit message override"),
+        path: external_exports.string().optional().describe("Required local path to a threadnote-bundle.json manifest"),
+        preview: external_exports.boolean().optional().describe("Return what would land in the shared git repo without writing"),
+        push: external_exports.boolean().optional().describe("Push to remote after committing; defaults to true"),
+        redact: external_exports.boolean().optional().describe("Replace soft-leak matches (local paths) with placeholders and continue; credentials still block."),
+        team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
+      }
+    },
+    async ({ allowBinary, force, message, path, preview, push, redact, team }) => {
+      const checkedPath = requiredText(path, "share_bundle", "path", {
+        path: "~/src/reviewer/threadnote-bundle.json"
+      });
+      if (!checkedPath.ok) {
+        return checkedPath.error;
+      }
+      return runShareBundleTool(config2, checkedPath.value, { allowBinary, force, message, preview, push, redact, team });
+    }
+  );
   server.registerTool(
     "list_shared_skills",
     {
       annotations: { readOnlyHint: true, destructiveHint: false },
-      description: "List shared Codex/Claude skills and Claude commands available in a configured Threadnote team repo, including whether each one is already installed locally.",
+      description: "List shared Codex/Claude skills, Claude commands, and skill packs available in a configured Threadnote team repo, including whether each one is already installed locally.",
       inputSchema: {
         agent: external_exports.enum(["codex", "claude"]).optional().describe("Optional agent filter"),
-        kind: external_exports.enum(["skill", "command"]).optional().describe("Optional kind filter"),
+        kind: external_exports.enum(["skill", "command", "pack"]).optional().describe("Optional kind filter"),
         name: external_exports.string().optional().describe("Optional shared artifact name filter"),
         team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
       }
@@ -38611,7 +39837,7 @@ function registerTools(server, config2) {
         agent: external_exports.enum(["codex", "claude"]).optional().describe("Agent owner; required when name is ambiguous"),
         dryRun: external_exports.boolean().optional().describe("Preview install without writing local files"),
         force: external_exports.boolean().optional().describe("Replace an existing installed artifact with different content"),
-        kind: external_exports.enum(["skill", "command"]).optional().describe("Artifact kind; required when name is ambiguous"),
+        kind: external_exports.enum(["skill", "command", "pack"]).optional().describe("Artifact kind; required when name is ambiguous"),
         name: external_exports.string().optional().describe("Required shared artifact name to install"),
         team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
       }
@@ -39045,7 +40271,8 @@ async function runRecallTool(config2, params) {
     passes.push(seeded.hits);
   }
   const sections = [];
-  const semanticSection = formatRecallHits(mergeRecallHits(passes), params.nodeLimit ?? 12);
+  const exactMatches = await collectExactMemoryMatches(config2, query, params.includeArchived, project);
+  const { semanticSection, exactTail } = buildRecallSections(passes, exactMatches, params.nodeLimit ?? 12);
   if (semanticSection) {
     sections.push(semanticSection);
   } else if (!base.ok) {
@@ -39054,9 +40281,8 @@ async function runRecallTool(config2, params) {
   if (indexRepairMessages.length > 0) {
     sections.push(indexRepairMessages.join("\n"));
   }
-  const exactMatches = await exactMemoryMatchesText(config2, query, params.includeArchived, project);
-  if (exactMatches) {
-    sections.push(exactMatches);
+  if (exactTail) {
+    sections.push(exactTail);
   }
   const hygieneHints = await recallHygieneHintsSection(config2, sections.join("\n\n"));
   if (hygieneHints) {
@@ -39103,14 +40329,14 @@ async function recallHygieneHintsSection(config2, recallText) {
   const nudges = recallHygieneNudges(recallText, { records, user: config2.user });
   return nudges.length > 0 ? ["Memory hygiene hints:", ...nudges.map((nudge) => `- ${nudge}`)].join("\n") : void 0;
 }
-async function exactMemoryMatchesText(config2, query, includeArchived, project) {
+async function collectExactMemoryMatches(config2, query, includeArchived, project) {
   const terms = exactRecallTerms(query);
   if (terms.length === 0) {
-    return void 0;
+    return [];
   }
   const ov = await requiredOpenVikingCli2();
   const scopes = exactMemoryScopes(config2, includeArchived, query, project);
-  const matches = await collectExactMatches(terms, scopes, async (term, scope) => {
+  return collectExactMatches(terms, scopes, async (term, scope) => {
     const result = await runCommand(
       ov,
       withIdentity2(config2, ["grep", term, "--uri", scope, "--node-limit", "5", "--output", "json"]),
@@ -39118,7 +40344,6 @@ async function exactMemoryMatchesText(config2, query, includeArchived, project)
     );
     return result.exitCode === 0 ? result.stdout : void 0;
   });
-  return formatExactMatchPointers(matches);
 }
 function registerReadTool(server, config2, name, description) {
   server.registerTool(
@@ -39998,6 +41223,34 @@ async function runShareSkillTool(config2, sourcePath, options) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function runShareBundleTool(config2, manifestPath, options) {
+  try {
+    const result = await shareBundlePack(config2, manifestPath, options);
+    const lines = [...result.messages, ...result.gitMessages];
+    if (result.previewContent !== void 0) {
+      lines.push("-----BEGIN PREVIEW-----");
+      lines.push(result.previewContent);
+      lines.push("-----END PREVIEW-----");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+async function runThreadnoteGuideTool(config2) {
+  const serverUp = await probeServerUp(config2);
+  const context = await gatherOnboardingContext(config2);
+  const text = buildOnboardingGuide({ ...context, serverUp });
+  return { content: [{ type: "text", text }], isError: false };
+}
+async function probeServerUp(config2) {
+  try {
+    const result = await runOpenVikingMcpTool(config2, "health", {});
+    return result.isError !== true;
+  } catch (_err) {
+    return false;
+  }
+}
 async function runListSharedSkillsTool(config2, options) {
   try {
     const result = await listSharedAgentArtifacts(config2, options);