threadnote 0.7.5 → 0.7.7

package/dist/mcp_server.cjs

@@ -30952,7 +30952,7 @@ var StdioServerTransport = class {
 // src/mcp_server.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 
 // src/constants.ts
 var DEFAULT_ACCOUNT = "local";
@@ -33684,6 +33684,13 @@ async function runCommand(executable, args, options = {}) {
     });
   });
 }
+async function gitValue(args, cwd = getInvocationCwd()) {
+  const result = await runCommand("git", args, { allowFailure: true, cwd });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  return result.stdout.trim();
+}
 async function sleep(ms) {
   return new Promise((resolvePromise) => {
     setTimeout(resolvePromise, ms);
@@ -33723,6 +33730,57 @@ function expandPath(path) {
 function getInvocationCwd() {
   return process.env.THREADNOTE_CALLER_CWD ?? process.cwd();
 }
+function recallQueryRequestsWorkspaceContext(query) {
+  const normalized = query.toLowerCase();
+  return /\b(?:this|current)\s+(?:branch|repo|repository|workspace|worktree)\b/.test(normalized);
+}
+async function enrichRecallQueryWithWorkspaceContext(query, options = {}) {
+  return enrichRecallQueryWithWorkspaceTerms(query, options, true);
+}
+async function enrichRecallQueryWithWorkspaceProjectContext(query, options = {}) {
+  return enrichRecallQueryWithWorkspaceTerms(query, options, false);
+}
+async function enrichRecallQueryWithWorkspaceTerms(query, options, includeBranch) {
+  if (!recallQueryRequestsWorkspaceContext(query)) {
+    return query;
+  }
+  const terms = await currentWorkspaceRecallTerms(options, includeBranch);
+  const additions = terms.filter((term) => !query.toLowerCase().includes(term.toLowerCase()));
+  return additions.length > 0 ? `${query} ${additions.join(" ")}` : query;
+}
+async function currentWorkspaceRecallTerms(options, includeBranch) {
+  const cwd = options.cwd ?? (options.includeProcessCwd === false ? void 0 : getInvocationCwd());
+  if (!cwd || !(0, import_node_path.isAbsolute)(cwd)) {
+    return [];
+  }
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"], cwd);
+  if (!repoRoot) {
+    return [];
+  }
+  const branch = await gitValue(["branch", "--show-current"], repoRoot);
+  const parent = (0, import_node_path.dirname)(repoRoot);
+  return uniqueUsefulWorkspaceTerms([
+    { source: "branch", value: includeBranch ? branch : void 0 },
+    { source: "path", value: (0, import_node_path.basename)(repoRoot) },
+    { source: "path", value: parent === (0, import_node_os.homedir)() ? void 0 : (0, import_node_path.basename)(parent) }
+  ]);
+}
+function uniqueUsefulWorkspaceTerms(values) {
+  const ignored = /* @__PURE__ */ new Set(["repos", "repositories", "workspaces", "worktrees"]);
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  for (const { source, value } of values) {
+    const term = value?.trim();
+    const normalized = term?.toLowerCase();
+    const tooShort = source === "branch" ? false : (term?.length ?? 0) < 4;
+    if (!term || !normalized || tooShort || ignored.has(normalized) || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    terms.push(term);
+  }
+  return terms;
+}
 function trimTrailingSlash(value) {
   return value.endsWith("/") ? value.slice(0, -1) : value;
 }
@@ -33738,19 +33796,29 @@ function exactRecallTerms(query) {
     "branch",
     "case",
     "current",
+    "durable",
     "find",
+    "feature",
+    "features",
     "handoff",
     "issue",
     "issues",
+    "knowledge",
     "latest",
     "memory",
     "memories",
+    "project",
     "recall",
+    "repo",
+    "repository",
     "related",
     "search",
-    "the",
+    "stored",
     "this",
-    "with"
+    "the",
+    "with",
+    "workspace",
+    "worktree"
   ]);
   const seen = /* @__PURE__ */ new Set();
   const terms = [];
@@ -33863,10 +33931,435 @@ function readStringArray(object3, key) {
   return value;
 }
 
+// src/memory_hygiene.ts
+var import_node_path2 = 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 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]);
+  }
+  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;
+    }
+    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 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 parsePersonalMemoryUri(uri, user) {
+  const prefix = `viking://user/${uriSegment(user)}/memories/`;
+  if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
+    return void 0;
+  }
+  const rest = uri.slice(prefix.length);
+  const parts = rest.split("/").filter(Boolean);
+  if (parts.length < 4) {
+    return void 0;
+  }
+  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$/, "") };
+  }
+  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;
+}
+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 };
+}
+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_path2.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 (parts[0] === "durable" && parts[1] === "projects") {
+    return parts[2];
+  }
+  return void 0;
+}
+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_path2.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 (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 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;
+}
+function compareGroupedRecordLists(left, right) {
+  return (left[0]?.groupKey ?? "").localeCompare(right[0]?.groupKey ?? "");
+}
+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;
+}
+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;
+  }
+  return void 0;
+}
+function parseOptionalMemoryStatus(value) {
+  if (!value) {
+    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 isCompactableKind(kind) {
+  return kind === "durable" || kind === "handoff" || kind === "incident";
+}
+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 formatPlanSection(title, lines) {
+  if (lines.length === 0) {
+    return `${title}:
+- none`;
+  }
+  return [`${title}:`, ...lines.map((line) => `- ${line}`)].join("\n");
+}
+
 // src/share.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_os2 = require("node:os");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 
 // src/runtime.ts
 function withIdentity(config2, args) {
@@ -33980,7 +34473,7 @@ function autoShareState(config2) {
   return state;
 }
 function pendingReindexesPath(config2) {
-  return (0, import_node_path2.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+  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));
@@ -34024,7 +34517,7 @@ async function writePendingReindexes(config2, state) {
     teams: Object.fromEntries(state.pendingReindexes),
     version: 1
   };
-  await (0, import_promises3.mkdir)((0, import_node_path2.dirname)(path), { recursive: true });
+  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
   await (0, import_promises3.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
@@ -34124,7 +34617,7 @@ async function runShareSyncQuiet(config2, state, options) {
   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_path2.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path2.join)(team.config.gitdir, "rebase-apply"))) {
+    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.`
       );
@@ -34157,10 +34650,10 @@ function normalizeTeamName(input) {
   return candidate;
 }
 function teamsFilePath(config2) {
-  return (0, import_node_path2.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_path2.join)(
+  return (0, import_node_path3.join)(
     config2.agentContextHome,
     "data",
     "viking",
@@ -34173,7 +34666,7 @@ function teamWorktreePath(config2, team) {
   );
 }
 function teamGitdirPath(config2, team) {
-  return (0, import_node_path2.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);
@@ -34229,11 +34722,39 @@ async function resolveTeam(config2, requested) {
   return { config: found, name: wantName };
 }
 function workfileToVikingUri(config2, team, filePath) {
-  const rel = (0, import_node_path2.relative)(team.worktree, filePath).split(import_node_path2.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) {
-  return uri.startsWith(`viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`);
+  return sharedTeamNameForUri(config2, uri) !== void 0;
+}
+function sharedTeamNameForUri(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team] = uri.slice(prefix.length).split("/");
+  return team || void 0;
+}
+function sharedMemoryUriParts(config2, uri) {
+  const prefix = `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/`;
+  if (!uri.startsWith(prefix)) {
+    return void 0;
+  }
+  const [team, kind, scope, project, ...topicParts] = uri.slice(prefix.length).split("/");
+  if (!team) {
+    return void 0;
+  }
+  if (kind !== "durable" || scope !== "projects" || !project || topicParts.length === 0) {
+    return { team };
+  }
+  const topicPath = topicParts.join("/");
+  return {
+    kind,
+    project,
+    team,
+    topic: topicPath.endsWith(".md") ? topicPath.slice(0, -".md".length) : topicPath
+  };
 }
 function sharedUriFor(config2, personalUri, team) {
   const prefix = `viking://user/${uriSegment(config2.user)}/memories/`;
@@ -34326,8 +34847,8 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, o
     }
     return;
   }
-  const stagingDir = await (0, import_promises3.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path2.join)(stagingDir, "body.txt");
+  const stagingDir = await (0, import_promises3.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_promises3.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode, options);
@@ -34449,7 +34970,7 @@ async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
   if (!relative2) {
     return;
   }
-  await (0, import_promises3.rm)((0, import_node_path2.join)(worktree, relative2), { force: true });
+  await (0, import_promises3.rm)((0, import_node_path3.join)(worktree, relative2), { force: true });
 }
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config2, ["rm", uri]);
@@ -34513,8 +35034,8 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
       const oldRel = entries[index + 1];
       const newRel = entries[index + 2];
       if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path2.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path2.join)(worktree, newRel), relativePath: newRel, status: "added" });
+        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;
@@ -34522,7 +35043,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
     const rel = entries[index + 1];
     if (rel) {
       const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path2.join)(worktree, rel), relativePath: rel, status });
+      changes.push({ path: (0, import_node_path3.join)(worktree, rel), relativePath: rel, status });
     }
     index += 2;
   }
@@ -34604,13 +35125,14 @@ async function main() {
         "",
         "Stdio MCP adapter for Threadnote shared local context.",
         "Prefer `recall_context` to find candidate viking:// URIs, then `read_context` files or `list_context` directories.",
-        'Always pass JSON arguments. Example: recall_context({"query":"current repo latest handoff"}).',
+        'Always pass JSON arguments. Example: recall_context({"query":"current repo latest handoff","callerCwd":"/absolute/workspace/path"}).',
         "recall_context also surfaces seeded project resources under viking://resources/repos/<project> when the query mentions a project from the seed manifest. See its tool description for the query convention.",
         "Older clients may use the compatibility aliases `search`, `read`, and `list`.",
         'For durable facts, store kind="durable"; for current work logs, store kind="handoff" with project/topic so Threadnote keeps one active memory updated.',
         "When a handoff describes an active branch or feature, recall durable feature memories for the same branch/topic before coding.",
         "During feature work, update durable feature knowledge when valuable implementation details, decisions, interfaces, or gotchas change.",
         "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate durable memories or handoffs do not accumulate.",
+        "Use compact_context with dryRun=true for scoped memory hygiene when recall surfaces overlapping active memories.",
         "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish is destructive: it scrubs for secrets, moves the memory into the shared subtree, removes the personal copy, and pushes a git commit. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
         "Do not store secrets, customer data, raw production logs, or credentials."
       ].join("\n")
@@ -34635,7 +35157,7 @@ function registerTools(server, config2) {
     server,
     config2,
     "recall_context",
-    `Search Threadnote context across personal memories and seeded project resources. Returns semantic hits from indexed Threadnote context (handoffs, durable feature memories, preferences, shared team memories) \u2014 and, when the query mentions a project name from the seed manifest, also from that project's seeded guidance (README, AGENTS.md, CLAUDE.md, SKILL.md, docs/**) under viking://resources/repos/<project>. Include the repo or project name in the query to make the project-guidance pass fire. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.`
+    `Search Threadnote context across personal memories and seeded project resources. Returns semantic hits from indexed Threadnote context (handoffs, durable feature memories, preferences, shared team memories) \u2014 and, when the query mentions a project name from the seed manifest, also from that project's seeded guidance (README, AGENTS.md, CLAUDE.md, SKILL.md, docs/**) under viking://resources/repos/<project>. Queries that mention this/current branch are enriched with local git/workspace terms when callerCwd is provided. Include the repo or project name in the query to make the project-guidance pass fire. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.`
   );
   registerSearchTool(
     server,
@@ -34666,6 +35188,7 @@ function registerTools(server, config2) {
     "Archive a memory so it remains readable as provenance but is no longer current working context."
   );
   registerArchiveTool(server, config2, "archive", "Compatibility alias for archive_context.");
+  registerCompactTool(server, config2);
   server.registerTool(
     "forget",
     {
@@ -34828,11 +35351,12 @@ function registerSearchTool(server, config2, name, description) {
       inputSchema: {
         query: external_exports.string().optional().describe('Required search query, for example "unity-ui-ccc latest handoff"'),
         uri: external_exports.string().optional().describe("Optional viking:// subtree to search"),
+        callerCwd: external_exports.string().optional().describe("Optional absolute caller workspace path used to resolve this/current branch queries"),
         nodeLimit: external_exports.number().int().positive().max(100).optional().describe("Maximum result count"),
-        includeArchived: external_exports.boolean().optional().describe("Include archived memories in exact durable-memory matches")
+        includeArchived: external_exports.boolean().optional().describe("Include archived memories in exact memory/resource matches")
       }
     },
-    async ({ includeArchived, nodeLimit, query, uri }) => {
+    async ({ callerCwd, includeArchived, nodeLimit, query, uri }) => {
       const checkedQuery = requiredText(query, name, "query", { query: "unity-ui-ccc latest handoff" });
       if (!checkedQuery.ok) {
         return checkedQuery.error;
@@ -34842,6 +35366,7 @@ function registerSearchTool(server, config2, name, description) {
         return checkedUri.error;
       }
       return runRecallTool(config2, {
+        callerCwd,
         query: checkedQuery.value,
         pinnedUri: checkedUri.value,
         nodeLimit,
@@ -34860,9 +35385,18 @@ async function runRecallTool(config2, params) {
   } catch (err) {
     syncWarnings.push(errorMessage(err));
   }
+  const query = await enrichRecallQueryWithWorkspaceContext(params.query, {
+    cwd: params.callerCwd,
+    includeProcessCwd: false
+  });
+  const projectQuery = await enrichRecallQueryWithWorkspaceProjectContext(params.query, {
+    cwd: params.callerCwd,
+    includeProcessCwd: false
+  });
+  const contextualParams = { ...params, query };
   const baseArgs = [
     "search",
-    params.query,
+    query,
     ...params.pinnedUri ? ["--uri", params.pinnedUri] : [],
     ...params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : []
   ];
@@ -34878,15 +35412,19 @@ async function runRecallTool(config2, params) {
   if (firstContent.text) {
     sections.push(firstContent.text);
   }
-  const seededSection = await seededResourcesSection(config2, params);
+  const seededSection = await seededResourcesSection(config2, contextualParams, projectQuery);
   if (seededSection) {
     sections.push(seededSection);
   }
-  const exactMatches = await exactMemoryMatchesText(config2, params.query, params.includeArchived);
+  const exactMatches = await exactMemoryMatchesText(config2, query, params.includeArchived);
   if (exactMatches) {
-    sections.push(`Exact durable memory matches:
+    sections.push(`Exact memory/resource matches:
 ${exactMatches}`);
   }
+  const hygieneHints = await recallHygieneHintsSection(config2, sections.join("\n\n"));
+  if (hygieneHints) {
+    sections.push(hygieneHints);
+  }
   if (syncedTeams.length > 0) {
     sections.push(`Auto-synced shared memories: ${syncedTeams.join(", ")}`);
   }
@@ -34898,11 +35436,20 @@ ${exactMatches}`);
   }
   return { ...semanticResult, content: [{ type: "text", text: sections.join("\n\n") }] };
 }
-async function seededResourcesSection(config2, params) {
+async function recallHygieneHintsSection(config2, recallText) {
+  const uris = activePersonalMemoryUrisFromText(recallText, config2.user);
+  if (uris.length === 0) {
+    return void 0;
+  }
+  const records = await readMemoryRecordsByUri(config2, uris);
+  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 seededResourcesSection(config2, params, projectQuery) {
   if (params.pinnedUri) {
     return void 0;
   }
-  const project = await inferProjectFromQuery(config2.manifestPath, params.query);
+  const project = await inferProjectFromQuery(config2.manifestPath, projectQuery);
   if (!project) {
     return void 0;
   }
@@ -35028,7 +35575,9 @@ function registerStoreTool(server, config2, name, description) {
       inputSchema: {
         kind: external_exports.enum(["durable", "handoff", "incident", "preference", "smoke"]).optional().describe("Memory lifecycle kind; durable facts and handoffs are most common"),
         project: external_exports.string().optional().describe("Project/repo namespace, for example threadnote or mobile-native"),
-        replaceUri: external_exports.string().optional().describe("Optional viking:// memory URI to forget after the new memory is safely stored"),
+        replaceUri: external_exports.string().optional().describe(
+          "Optional viking:// memory URI to replace. Shared URIs are updated in place and pushed; personal URIs are forgotten after the replacement is safely stored."
+        ),
         text: external_exports.string().optional().describe("Required memory text to store"),
         sourceAgentClient: external_exports.string().optional().describe("Originating client, for example cursor, copilot, codex, or claude"),
         status: external_exports.enum(["active", "archived", "superseded"]).optional().describe("Memory lifecycle status"),
@@ -35046,11 +35595,11 @@ function registerStoreTool(server, config2, name, description) {
       }
       const metadata = {
         kind: kind ?? "durable",
-        project: normalizeOptionalMetadata(project),
+        project: normalizeOptionalMetadata2(project),
         sourceAgentClient: sourceAgentClient ?? "mcp",
         status: status ?? "active",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        topic: normalizeOptionalMetadata(topic)
+        topic: normalizeOptionalMetadata2(topic)
       };
       return writeDurableMemory(config2, {
         bodyText: checkedText.value,
@@ -35091,11 +35640,11 @@ function registerArchiveTool(server, config2, name, description) {
         const metadata = {
           archivedFrom: checkedUri.value,
           kind: kind ?? "handoff",
-          project: normalizeOptionalMetadata(project),
+          project: normalizeOptionalMetadata2(project),
           sourceAgentClient: "mcp",
           status: "archived",
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          topic: normalizeOptionalMetadata(topic)
+          topic: normalizeOptionalMetadata2(topic)
         };
         const archiveResult = await writeDurableMemory(config2, {
           bodyText: ["Archived original Threadnote memory.", "", original].join("\n"),
@@ -35123,17 +35672,241 @@ Archive stored, but original memory is still processing. Retry later with forget
     }
   );
 }
+function registerCompactTool(server, config2) {
+  server.registerTool(
+    "compact_context",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Plan or apply scoped Threadnote memory hygiene. Defaults to dry-run; pass apply=true to archive stale handoffs and forget exact duplicates.",
+      inputSchema: {
+        apply: external_exports.boolean().optional().describe("Apply the compact plan; defaults to false"),
+        dryRun: external_exports.boolean().optional().describe("Keep the call read-only; defaults to true unless apply=true"),
+        kind: external_exports.enum(["durable", "handoff", "incident"]).optional().describe("Optional memory kind filter"),
+        project: external_exports.string().optional().describe("Required project/repo namespace, for example threadnote"),
+        topic: external_exports.string().optional().describe("Optional stable topic name")
+      }
+    },
+    async ({ apply, dryRun, kind, project, topic }) => {
+      const checkedProject = requiredText(project, "compact_context", "project", { project: "threadnote" });
+      if (!checkedProject.ok) {
+        return checkedProject.error;
+      }
+      if (apply === true && dryRun === true) {
+        return {
+          content: [{ type: "text", text: "compact_context cannot combine apply=true with dryRun=true." }],
+          isError: true
+        };
+      }
+      try {
+        const records = await scopedCompactRecords(config2, {
+          kind,
+          project: checkedProject.value
+        });
+        const plan = buildCompactPlan(records, {
+          kind,
+          project: checkedProject.value,
+          topic: normalizeOptionalMetadata2(topic)
+        });
+        const shouldApply = apply === true;
+        const planText = formatCompactPlan(plan, { apply: shouldApply });
+        if (!shouldApply) {
+          return { content: [{ type: "text", text: planText }] };
+        }
+        const ov = await requiredOpenVikingCli2();
+        const appliedMessages = [];
+        for (const action of plan.keepUpdates) {
+          const result = await runOpenVikingWriteWithRetry(
+            ov,
+            config2,
+            action.uri,
+            withIdentity2(config2, [
+              "write",
+              action.uri,
+              "--content",
+              action.content,
+              "--mode",
+              "replace",
+              "--wait",
+              "--timeout",
+              "120"
+            ])
+          );
+          appliedMessages.push(`Updated kept memory: ${action.uri}`);
+          const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+          if (output) {
+            appliedMessages.push(output);
+          }
+        }
+        for (const action of plan.archives) {
+          const archiveResult = await archiveMemoryForCompact(config2, ov, action);
+          if (archiveResult.isError === true) {
+            return archiveResult;
+          }
+          const [content] = archiveResult.content;
+          if (content?.type === "text") {
+            appliedMessages.push(content.text);
+          }
+        }
+        for (const action of plan.forgets) {
+          const removed = await removeVikingResourceWithRetry(ov, config2, action.uri);
+          appliedMessages.push(
+            removed ? `Forgot exact duplicate: ${action.uri}` : `Exact duplicate is still processing; retry later with forget: ${action.uri}`
+          );
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: [planText, "", "Applied actions:", ...appliedMessages.map((message) => `- ${message}`)].join("\n")
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+      }
+    }
+  );
+}
+async function archiveMemoryForCompact(config2, ov, action) {
+  const readResult = await runCommand(ov, withIdentity2(config2, ["read", action.uri]));
+  const original = readResult.stdout.trim();
+  if (!original) {
+    return { content: [{ type: "text", text: `Could not read ${action.uri} before archiving.` }], isError: true };
+  }
+  const archiveResult = await writeDurableMemory(config2, {
+    bodyText: ["Archived original Threadnote memory.", "", original].join("\n"),
+    metadata: {
+      archivedFrom: action.uri,
+      kind: action.kind,
+      project: action.project,
+      sourceAgentClient: "mcp",
+      status: "archived",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      topic: action.topic
+    }
+  });
+  if (archiveResult.isError === true) {
+    return archiveResult;
+  }
+  const removedOriginal = await removeVikingResourceWithRetry(ov, config2, action.uri);
+  const [content] = archiveResult.content;
+  const text = content?.type === "text" ? content.text : "Archived memory stored.";
+  return {
+    content: [
+      {
+        type: "text",
+        text: removedOriginal ? `${text}
+Archived original memory: ${action.uri}` : `${text}
+Archive stored, but original memory is still processing. Retry later with forget: ${action.uri}`
+      }
+    ]
+  };
+}
+async function scopedCompactRecords(config2, options) {
+  const kinds = options.kind ? [options.kind] : ["handoff", "durable", "incident"];
+  const records = [];
+  for (const kind of kinds) {
+    const directory = localMemoryDirectoryForCompact(config2, kind, options.project);
+    const uriDirectory = memoryUriDirectoryForCompact(config2, kind, options.project);
+    let entries;
+    try {
+      entries = await (0, import_promises4.readdir)(directory, { withFileTypes: true });
+    } catch (_err) {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const content = await readTextIfExists((0, import_node_path4.join)(directory, entry.name));
+      if (!content) {
+        continue;
+      }
+      const record2 = parseMemoryDocument(`${uriDirectory}/${entry.name}`, content);
+      if (record2) {
+        records.push(record2);
+      }
+    }
+  }
+  return records;
+}
+async function readMemoryRecordsByUri(config2, uris) {
+  const records = [];
+  for (const uri of uris) {
+    const localPath = localMemoryPathForUri(config2, uri);
+    if (!localPath) {
+      continue;
+    }
+    const content = await readTextIfExists(localPath);
+    if (!content) {
+      continue;
+    }
+    const record2 = parseMemoryDocument(uri, content);
+    if (record2) {
+      records.push(record2);
+    }
+  }
+  return records;
+}
+function localMemoryDirectoryForCompact(config2, kind, project) {
+  const root = localUserMemoriesRoot(config2);
+  const projectSegment = uriSegment2(project);
+  switch (kind) {
+    case "durable":
+      return (0, import_node_path4.join)(root, "durable", "projects", projectSegment);
+    case "handoff":
+      return (0, import_node_path4.join)(root, "handoffs", "active", projectSegment);
+    case "incident":
+      return (0, import_node_path4.join)(root, "incidents", "active", projectSegment);
+  }
+}
+function memoryUriDirectoryForCompact(config2, kind, project) {
+  const base = `viking://user/${uriSegment2(config2.user)}/memories`;
+  const projectSegment = uriSegment2(project);
+  switch (kind) {
+    case "durable":
+      return `${base}/durable/projects/${projectSegment}`;
+    case "handoff":
+      return `${base}/handoffs/active/${projectSegment}`;
+    case "incident":
+      return `${base}/incidents/active/${projectSegment}`;
+  }
+}
+function localMemoryPathForUri(config2, uri) {
+  const prefix = `viking://user/${uriSegment2(config2.user)}/memories/`;
+  if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
+    return void 0;
+  }
+  const relative2 = uri.slice(prefix.length);
+  if (relative2.includes("..") || relative2.startsWith("/")) {
+    return void 0;
+  }
+  return (0, import_node_path4.join)(localUserMemoriesRoot(config2), ...relative2.split("/"));
+}
+function localUserMemoriesRoot(config2) {
+  return (0, import_node_path4.join)(config2.agentContextHome, "data", "viking", config2.account, "user", uriSegment2(config2.user), "memories");
+}
+async function readTextIfExists(path) {
+  try {
+    return await (0, import_promises4.readFile)(path, "utf8");
+  } catch (_err) {
+    return void 0;
+  }
+}
 async function writeDurableMemory(config2, params) {
   try {
     const ov = await requiredOpenVikingCli2();
+    if (params.replaceUri && isInSharedNamespace(config2, params.replaceUri)) {
+      return await writeSharedMemoryReplacement(config2, ov, params, params.replaceUri);
+    }
     const directoryUri = memoryDirectoryUri(config2, params.metadata);
     await ensureMemoryDirectory(ov, config2, directoryUri);
     const candidateMetadata = { ...params.metadata, supersedes: params.replaceUri };
-    const candidateMemory = formatMemoryDocument("MEMORY", candidateMetadata, params.bodyText);
+    const candidateMemory = formatMemoryDocument2("MEMORY", candidateMetadata, params.bodyText);
     const memoryUri = memoryUriFor(config2, candidateMemory, candidateMetadata);
     const isInPlaceUpdate = params.replaceUri !== void 0 && params.replaceUri === memoryUri;
     const finalMetadata = isInPlaceUpdate ? { ...params.metadata, supersedes: void 0 } : candidateMetadata;
-    const memory = isInPlaceUpdate ? formatMemoryDocument("MEMORY", finalMetadata, params.bodyText) : candidateMemory;
+    const memory = isInPlaceUpdate ? formatMemoryDocument2("MEMORY", finalMetadata, params.bodyText) : candidateMemory;
     const writeMode = await memoryWriteMode(ov, config2, memoryUri, finalMetadata);
     const result = await runOpenVikingWriteWithRetry(
       ov,
@@ -35166,6 +35939,40 @@ async function writeDurableMemory(config2, params) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
+  if (params.metadata.kind !== "durable") {
+    return argumentError("Shared memory replacement only supports durable memories.");
+  }
+  const teamName = sharedTeamNameForUri(config2, targetUri);
+  if (!teamName) {
+    return argumentError(`Memory ${targetUri} is not in the shared namespace.`);
+  }
+  const resolved = await resolveTeam(config2, teamName);
+  const inferred = sharedMemoryUriParts(config2, targetUri);
+  const metadata = {
+    ...params.metadata,
+    project: params.metadata.project ?? inferred?.project,
+    topic: params.metadata.topic ?? inferred?.topic
+  };
+  const rawMemory = formatMemoryDocument2("MEMORY", metadata, params.bodyText);
+  const scrub = applyScrubber(stripPersonalProvenance(rawMemory), { redact: false });
+  if (scrub.blocker) {
+    return argumentError(
+      `Refusing to update shared memory ${targetUri}: possible ${scrub.blocker}. Strip the sensitive value first.`
+    );
+  }
+  await ensureSharedDirectoryChain(config2, ov, targetUri, false, { quiet: true });
+  await writeMemoryFile(config2, ov, targetUri, scrub.cleaned, "replace", false, { quiet: true });
+  const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
+  const messages = [`Updated shared memory: ${targetUri}`];
+  for (const redaction of scrub.redactions) {
+    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
+  }
+  messages.push(
+    ...await gitPublishWorkflow(resolved.config.worktree, relativePath, `share: update ${relativePath}`, true)
+  );
+  return { content: [{ type: "text", text: messages.join("\n") }] };
+}
 async function runOpenVikingWriteWithRetry(ov, config2, memoryUri, args) {
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
@@ -35280,7 +36087,7 @@ function exactMemoryScopes(config2, includeArchived) {
   ];
   return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
 }
-function formatMemoryDocument(title, metadata, body) {
+function formatMemoryDocument2(title, metadata, body) {
   const header = [
     title,
     `kind: ${metadata.kind}`,
@@ -35294,7 +36101,7 @@ function formatMemoryDocument(title, metadata, body) {
   ].filter((line) => line !== void 0);
   return [...header, "", body.trim()].join("\n");
 }
-function normalizeOptionalMetadata(value) {
+function normalizeOptionalMetadata2(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : void 0;
 }
@@ -35484,7 +36291,7 @@ function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path3.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  const command = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
   if (!command) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }