threadnote 0.6.2 → 0.7.0

package/README.md

@@ -350,8 +350,10 @@ This is it! Start working with your agents as usual. The agent will automaticall
 - `forget`: removes a `viking://` URI.
 - `export-pack` / `import-pack`: moves local context through `.ovpack` files.
 - `share init|status|sync|publish|unpublish|list|remove`: opts a curated subset of durable memories into a team git
-  repo so teammates can pull them. Personal handoffs and preferences stay local. See `docs/share.md` for the full
-  workflow and the publish-time scrubber rules.
+  repo. Threadnote periodically fetches configured share repos and automatically syncs clean incoming changes before
+  agent recall/read; use `share sync` for dirty worktrees, conflicts, explicit pushes, or immediate manual sync.
+  Personal handoffs and preferences stay local. See `docs/share.md` for the full workflow and the publish-time scrubber
+  rules.
 
 ## Source Checkout
 
@@ -427,4 +429,6 @@ threadnote list viking://agent/threadnote/memories --all --recursive
 
 When MCP is installed, the agent should use Threadnote MCP `recall_context`, then `read_context` or `list_context`.
 Agents must pass JSON arguments, for example `recall_context({"query":"agent context"})`. Older adapters expose
-`search`, `read`, and `list` aliases. The CLI commands are the fallback path.
+`search`, `read`, and `list` aliases. Before recall/read returns, Threadnote automatically syncs clean incoming shared
+memory updates when a configured share repo is behind; failures are reported as warnings and the local read still
+continues. The CLI commands are the fallback path.

package/dist/mcp_server.cjs

@@ -33608,6 +33608,26 @@ function redactText(content) {
     "$1[REDACTED]"
   ).replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{16,}/g, "sk-[REDACTED]").replace(/gh[pousr]_[A-Za-z0-9_]{16,}/g, "gh_[REDACTED]");
 }
+async function requiredOpenVikingCli() {
+  const command = await findExecutable(["ov", "openviking"]);
+  if (!command) {
+    throw new Error("Neither ov nor openviking was found in PATH. Run threadnote install first.");
+  }
+  return command;
+}
+async function openVikingCliForMode(dryRun) {
+  if (dryRun) {
+    return await findExecutable(["ov", "openviking"]) ?? "ov";
+  }
+  return requiredOpenVikingCli();
+}
+async function requiredExecutable(command) {
+  const executable = await findExecutable([command]);
+  if (!executable) {
+    throw new Error(`${command} was not found in PATH.`);
+  }
+  return executable;
+}
 async function findExecutable(commands) {
   for (const command of commands) {
     const result = await runCommand("which", [command], { allowFailure: true });
@@ -33669,6 +33689,21 @@ async function sleep(ms) {
     setTimeout(resolvePromise, ms);
   });
 }
+async function exists(path) {
+  try {
+    await (0, import_promises.access)(path);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+async function isFile(path) {
+  try {
+    return (await (0, import_promises.stat)(path)).isFile();
+  } catch (_err) {
+    return false;
+  }
+}
 async function readFileIfExists(path) {
   try {
     return await (0, import_promises.readFile)(path, "utf8");
@@ -33841,6 +33876,8 @@ function withIdentity(config2, args) {
 // src/share.ts
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
+var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
+var AUTO_SHARE_FETCH_INTERVAL_MS = 5 * 60 * 1e3;
 var DEFAULT_GIT_REMOTE_NAME = "origin";
 var SCRUBBER_PATTERNS = [
   // Credentials: never redactable. Blocking is the only safe response —
@@ -33886,6 +33923,231 @@ function applyScrubber(content, { redact }) {
   }
   return { cleaned, redactions };
 }
+var autoShareStates = /* @__PURE__ */ new Map();
+function startShareBackgroundFetch(config2) {
+  const state = autoShareState(config2);
+  if (state.timer) {
+    return;
+  }
+  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 syncedTeams = [];
+    const remainingBehind = new Set(state.behindTeams);
+    for (const team of syncTeams) {
+      try {
+        const warning = await runShareSyncQuiet(config2, state, { team });
+        if (warning) {
+          warnings.push(warning);
+        } else {
+          remainingBehind.delete(team);
+          syncedTeams.push(team);
+        }
+      } catch (err) {
+        warnings.push(
+          `Auto-sync for shared team "${team}" failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    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_path2.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;
+    }
+    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 });
+      }
+    }
+    if (changes.length > 0) {
+      pending.set(team, changes);
+    }
+  }
+  state.pendingReindexes = pending;
+}
+async function writePendingReindexes(config2, state) {
+  const path = pendingReindexesPath(config2);
+  if (state.pendingReindexes.size === 0) {
+    await (0, import_promises3.rm)(path, { force: true });
+    return;
+  }
+  const contents = {
+    teams: Object.fromEntries(state.pendingReindexes),
+    version: 1
+  };
+  await (0, import_promises3.mkdir)((0, import_node_path2.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 });
+  await (0, import_promises3.rename)(tempPath, path);
+}
+async function refreshShareUpdateState(config2, options) {
+  const state = autoShareState(config2);
+  const warnings = await enqueueShareOperation(
+    state,
+    async () => refreshShareUpdateStateLocked(config2, state, options)
+  );
+  for (const warning of warnings) {
+    console.error(warning);
+  }
+}
+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) {
+    await applyChangesToOpenViking(config2, team.config, pendingChanges, { quiet: true });
+    state.pendingReindexes.delete(team.name);
+    await writePendingReindexes(config2, state);
+  }
+  if (await hasUncommittedChanges(worktree)) {
+    return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
+  }
+  const 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_path2.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path2.join)(team.config.gitdir, "rebase-apply"))) {
+      throw new Error(
+        `Automatic share sync hit git conflicts in ${worktree}. Resolve them in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then rerun recall/read.`
+      );
+    }
+    throw new Error(
+      `Automatic share sync failed in ${worktree}: ${pullResult.stderr.trim() || pullResult.stdout.trim() || "unknown error"}`
+    );
+  }
+  const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], false);
+  if (beforeRev && afterRev && beforeRev !== afterRev) {
+    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
+    if (changes.length > 0) {
+      state.pendingReindexes.set(team.name, changes);
+      await writePendingReindexes(config2, state);
+      await applyChangesToOpenViking(config2, team.config, changes, { quiet: true });
+      state.pendingReindexes.delete(team.name);
+      await writePendingReindexes(config2, state);
+    }
+  }
+  return void 0;
+}
 function normalizeTeamName(input) {
   const candidate = (input ?? "default").trim();
   if (!candidate) {
@@ -33970,6 +34232,10 @@ 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("/");
+  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}/`);
 }
@@ -34009,19 +34275,25 @@ function stripPersonalProvenance(content) {
   }
   return cleaned.join("\n");
 }
-async function ensureSharedDirectoryChain(config2, ov, memoryUri, dryRun) {
+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) {
-      console.log(`Would run: ${formatShellCommand(ov, args)}`);
+      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;
     }
-    await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+    if (options.quiet === true) {
+      await runCommand(ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+    } else {
+      await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+    }
   }
 }
 function parentUri(uri) {
@@ -34040,7 +34312,7 @@ function sharedDirectoryChain(config2, directoryUri) {
   }
   return chain;
 }
-async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun) {
+async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, options = {}) {
   if (dryRun) {
     const args = withIdentity(config2, [
       "write",
@@ -34053,19 +34325,21 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun) {
       "--timeout",
       "120"
     ]);
-    console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    }
     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");
   try {
     await (0, import_promises3.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
-    await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode);
+    await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode, options);
   } finally {
     await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
   }
 }
-async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode) {
+async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, options = {}) {
   const maxAttempts = 4;
   const existedBeforeWrite = await vikingResourceExists(ov, config2, uri);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
@@ -34083,20 +34357,26 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode) {
       "--timeout",
       "120"
     ]);
-    console.log(`${attempt === 0 ? "Running" : "Retrying"}: ${formatShellCommand(ov, args)}`);
+    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 (result.stdout.trim()) {
+      if (options.quiet !== true && result.stdout.trim()) {
         console.log(result.stdout.trim());
       }
-      if (result.stderr.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) {
-      console.log("OpenViking accepted the write but returned an error before the wait completed; draining the queue.");
-      await waitForOvQueue(ov, config2);
+      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) {
@@ -34105,12 +34385,12 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode) {
     await sleep(1e3 * (attempt + 1));
   }
 }
-async function waitForOvQueue(ov, config2) {
+async function waitForOvQueue(ov, config2, options = {}) {
   const result = await runCommand(ov, withIdentity(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
-  if (result.stdout.trim()) {
+  if (options.quiet !== true && result.stdout.trim()) {
     console.log(result.stdout.trim());
   }
-  if (result.stderr.trim()) {
+  if (options.quiet !== true && result.stderr.trim()) {
     console.error(result.stderr.trim());
   }
 }
@@ -34119,6 +34399,10 @@ function isTransientOvFailure(stderr, stdout) {
 ${stdout}`.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");
 }
+async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
+  const content = await (0, import_promises3.readFile)(filePath, "utf8");
+  await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
+}
 async function removeWithRollback(config2, ov, sourceUri, rollbackUri, worktree, dryRun, label) {
   try {
     await removeMemoryUri(config2, ov, sourceUri, dryRun);
@@ -34160,17 +34444,19 @@ async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
   }
   await (0, import_promises3.rm)((0, import_node_path2.join)(worktree, relative2), { force: true });
 }
-async function removeMemoryUri(config2, ov, uri, dryRun) {
+async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config2, ["rm", uri]);
   if (dryRun) {
-    console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    if (options.quiet !== true) {
+      console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    }
     return;
   }
   const maxAttempts = 4;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
-      if (result.stdout.trim()) {
+      if (options.quiet !== true && result.stdout.trim()) {
         console.log(result.stdout.trim());
       }
       return;
@@ -34185,6 +34471,81 @@ 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_path2.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path2.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_path2.join)(worktree, rel), relativePath: rel, status });
+    }
+    index += 2;
+  }
+  return changes;
+}
+async function applyChangesToOpenViking(config2, team, changes, options = {}) {
+  const ov = await openVikingCliForMode(false);
+  for (const change of changes) {
+    if (!change.relativePath.endsWith(".md")) {
+      continue;
+    }
+    const firstSegment = change.relativePath.split("/")[0];
+    if (!SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment)) {
+      continue;
+    }
+    const uri = workfileToVikingUri(config2, team, change.path);
+    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);
+  }
+}
 
 // src/mcp_server.ts
 async function main() {
@@ -34210,6 +34571,7 @@ async function main() {
     }
   );
   registerTools(server, config2);
+  startShareBackgroundFetch(config2);
   await server.connect(new StdioServerTransport());
   process.stderr.write("Threadnote local MCP adapter running\n");
 }
@@ -34273,7 +34635,7 @@ function registerTools(server, config2) {
         return checkedUri.error;
       }
       try {
-        const ov = await requiredOpenVikingCli();
+        const ov = await requiredOpenVikingCli2();
         const removed = await removeVikingResourceWithRetry(ov, config2, checkedUri.value);
         return {
           content: [
@@ -34443,6 +34805,15 @@ function registerSearchTool(server, config2, name, description) {
   );
 }
 async function runRecallTool(config2, params) {
+  let syncedTeams = [];
+  const syncWarnings = [];
+  try {
+    const syncResult = await syncSharedReposBeforeAgentRead(config2);
+    syncedTeams = syncResult.syncedTeams;
+    syncWarnings.push(...syncResult.warnings);
+  } catch (err) {
+    syncWarnings.push(errorMessage(err));
+  }
   const baseArgs = [
     "search",
     params.query,
@@ -34470,6 +34841,12 @@ async function runRecallTool(config2, params) {
     sections.push(`Exact durable memory matches:
 ${exactMatches}`);
   }
+  if (syncedTeams.length > 0) {
+    sections.push(`Auto-synced shared memories: ${syncedTeams.join(", ")}`);
+  }
+  for (const warning of syncWarnings) {
+    sections.push(`Auto-sync warning: ${warning}`);
+  }
   if (sections.length <= 1) {
     return semanticResult;
   }
@@ -34487,7 +34864,7 @@ async function seededResourcesSection(config2, params) {
   if (!projectResourceUri.startsWith("viking://")) {
     return void 0;
   }
-  const ov = await requiredOpenVikingCli();
+  const ov = await requiredOpenVikingCli2();
   const args = [
     "search",
     params.query,
@@ -34511,7 +34888,7 @@ async function exactMemoryMatchesText(config2, query, includeArchived) {
   if (terms.length === 0) {
     return void 0;
   }
-  const ov = await requiredOpenVikingCli();
+  const ov = await requiredOpenVikingCli2();
   const scopes = exactMemoryScopes(config2, includeArchived);
   const outputs = [];
   for (const term of terms) {
@@ -34542,7 +34919,27 @@ function registerReadTool(server, config2, name, description) {
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      return runOpenVikingTool(config2, ["read", checkedUri.value]);
+      let syncedTeams = [];
+      const syncWarnings = [];
+      try {
+        const syncResult = await syncSharedReposBeforeAgentRead(config2);
+        syncedTeams = syncResult.syncedTeams;
+        syncWarnings.push(...syncResult.warnings);
+      } catch (err) {
+        syncWarnings.push(errorMessage(err));
+      }
+      const result = await runOpenVikingTool(config2, ["read", checkedUri.value]);
+      if (result.isError === true || syncedTeams.length === 0 && syncWarnings.length === 0) {
+        return result;
+      }
+      const syncMessages = [
+        syncedTeams.length > 0 ? `Auto-synced shared memories: ${syncedTeams.join(", ")}` : void 0,
+        ...syncWarnings.map((warning) => `Auto-sync warning: ${warning}`)
+      ].filter((part) => part !== void 0);
+      return {
+        ...result,
+        content: [...result.content, { type: "text", text: syncMessages.join("\n") }]
+      };
     }
   );
 }
@@ -34636,7 +35033,7 @@ function registerArchiveTool(server, config2, name, description) {
         return checkedUri.error;
       }
       try {
-        const ov = await requiredOpenVikingCli();
+        const ov = await requiredOpenVikingCli2();
         const readResult = await runCommand(ov, withIdentity2(config2, ["read", checkedUri.value]));
         const original = readResult.stdout.trim();
         if (!original) {
@@ -34682,7 +35079,7 @@ Archive stored, but original memory is still processing. Retry later with forget
 }
 async function writeDurableMemory(config2, params) {
   try {
-    const ov = await requiredOpenVikingCli();
+    const ov = await requiredOpenVikingCli2();
     const directoryUri = memoryDirectoryUri(config2, params.metadata);
     await ensureMemoryDirectory(ov, config2, directoryUri);
     const candidateMetadata = { ...params.metadata, supersedes: params.replaceUri };
@@ -34908,7 +35305,7 @@ function argumentError(text) {
 }
 async function runOpenVikingTool(config2, args) {
   try {
-    const ov = await requiredOpenVikingCli();
+    const ov = await requiredOpenVikingCli2();
     const result = await runCommand(ov, withIdentity2(config2, args));
     const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
     return { content: [{ type: "text", text: text || "OK" }] };
@@ -34922,7 +35319,7 @@ async function runSharePublishTool(config2, sourceUri, options) {
       return argumentError(`Memory ${sourceUri} is already in the shared namespace.`);
     }
     const resolved = await resolveTeam(config2, options.team);
-    const ov = await requiredOpenVikingCli();
+    const ov = await requiredOpenVikingCli2();
     const readResult = await runCommand(ov, withIdentity2(config2, ["read", sourceUri]), { allowFailure: true });
     if (readResult.exitCode !== 0 || !readResult.stdout.trim()) {
       return {
@@ -35040,7 +35437,7 @@ async function gitPublishWorkflow(worktree, relativePath, commitMessage, push) {
 function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
-async function requiredOpenVikingCli() {
+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")]);
   if (!command) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");