threadnote 1.7.2 → 1.8.0

package/dist/mcp_server.cjs

@@ -37126,13 +37126,105 @@ async function fetchShareUpdateStatuses(config2) {
   }
   return statuses;
 }
+async function listShareConflicts(config2, options = {}) {
+  const teams = await teamsForShareQuery(config2, options.team);
+  const state = autoShareState(config2);
+  await loadPendingReindexes(config2, state);
+  const summaries = [];
+  for (const team of teams) {
+    const pending = state.pendingReindexes.get(team.name) ?? [];
+    for (const change of pending) {
+      if (!isShareableMemoryChange(change)) {
+        continue;
+      }
+      summaries.push(await buildShareConflictSummary(config2, team, normalizePendingChange(team, change)));
+    }
+  }
+  return summaries;
+}
+async function showShareConflict(config2, reference, options = {}) {
+  const conflict = await readPendingShareConflict(config2, reference, options.team);
+  const inspected = await inspectShareConflict(config2, conflict.team, conflict.change);
+  return {
+    ...inspected,
+    diff: formatShareConflictDiff(inspected),
+    resolutionGuidance: shareConflictResolutionGuidance(inspected.id)
+  };
+}
+async function resolveShareConflict(config2, reference, options) {
+  const fromFile = options.fromFile?.trim();
+  const mergedContent = options.mergedContent;
+  const rawTake = options.take;
+  if (rawTake !== void 0 && rawTake !== "shared" && rawTake !== "local") {
+    throw new Error(`Unsupported --take value "${rawTake}". Expected "shared" or "local".`);
+  }
+  const take = rawTake;
+  if ((take ? 1 : 0) + (fromFile ? 1 : 0) + (mergedContent !== void 0 ? 1 : 0) !== 1) {
+    throw new Error(
+      "Choose exactly one resolution: --take shared, --take local, --from-file <path>, or mergedContent via MCP."
+    );
+  }
+  const conflict = await readPendingShareConflict(config2, reference, options.team);
+  const inspected = await inspectShareConflict(config2, conflict.team, conflict.change);
+  const dryRun = options.dryRun === true;
+  const ov = await openVikingCliForMode(dryRun);
+  const messages = [];
+  const gitMessages = [];
+  const backupPath = dryRun ? void 0 : await backupShareConflict(config2, inspected);
+  if (take === "shared") {
+    if (inspected.status === "removed") {
+      if (inspected.hasLocalContent) {
+        await removeMemoryUri(config2, ov, inspected.uri, dryRun);
+        messages.push(`Accepted shared deletion for ${inspected.uri}.`);
+      } else {
+        messages.push(`Shared deletion was already reflected in OpenViking for ${inspected.uri}.`);
+      }
+    } else {
+      if (inspected.sharedContent === void 0) {
+        throw new Error(`Cannot take shared for ${inspected.id}: shared file is missing or not readable.`);
+      }
+      await ensureSharedDirectoryChain(config2, ov, inspected.uri, dryRun);
+      await writeMemoryFile(
+        config2,
+        ov,
+        inspected.uri,
+        inspected.sharedContent,
+        inspected.hasLocalContent ? "replace" : "create",
+        dryRun
+      );
+      messages.push(`Accepted shared file content for ${inspected.uri}.`);
+    }
+  } else {
+    const content = await conflictResolutionContent(inspected, take, fromFile, mergedContent);
+    await writeSharedConflictFile(conflict.team, inspected, content, dryRun);
+    await ensureSharedDirectoryChain(config2, ov, inspected.uri, dryRun);
+    await writeMemoryFile(config2, ov, inspected.uri, content, inspected.hasLocalContent ? "replace" : "create", dryRun);
+    const message = options.message ?? `share: resolve ${inspected.relativePath}`;
+    gitMessages.push(
+      ...await publishShareGitChange(conflict.team.config.worktree, inspected.relativePath, message, {
+        dryRun,
+        push: options.push
+      })
+    );
+    messages.push(
+      take === "local" ? `Published local OpenViking content for ${inspected.uri}.` : `Applied merged content for ${inspected.uri}.`
+    );
+  }
+  if (!dryRun) {
+    await clearPendingShareConflict(config2, conflict.team.name, inspected.relativePath);
+  }
+  return { backupPath, gitMessages, id: inspected.id, messages, team: inspected.team, uri: inspected.uri };
+}
 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 result = await applyAndPersistChanges(config2, team.config, state, pendingChanges, { quiet: true });
+    if (result.failed.length > 0) {
+      return `Shared team "${team.name}" has ${result.failed.length} pending shared memory conflict(s). Run \`threadnote share conflicts --team ${team.name}\` to inspect, then \`threadnote share conflict resolve <id> --take shared|local\` or \`--from-file <path>\`.`;
+    }
   }
   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.`;
@@ -37162,11 +37254,271 @@ async function runShareSyncQuiet(config2, state, options) {
     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 });
+      const result = await applyAndPersistChanges(config2, team.config, state, combined, { quiet: true });
+      if (result.failed.length > 0) {
+        return `Shared team "${team.name}" has ${result.failed.length} pending shared memory conflict(s). Run \`threadnote share conflicts --team ${team.name}\` to inspect, then \`threadnote share conflict resolve <id> --take shared|local\` or \`--from-file <path>\`.`;
+      }
     }
   }
   return void 0;
 }
+async function teamsForShareQuery(config2, teamName) {
+  if (teamName) {
+    return [await resolveTeam(config2, teamName)];
+  }
+  const teams = await readTeamsFile(config2);
+  const entries = Object.entries(teams.teams);
+  if (entries.length === 0) {
+    throw new Error("No shared teams configured. Run: threadnote share init <remote-url>");
+  }
+  return entries.map(([name, team]) => ({ config: team, name }));
+}
+async function readPendingShareConflict(config2, reference, optionTeam) {
+  const target = await parseShareConflictReference(config2, reference, optionTeam);
+  const state = autoShareState(config2);
+  await loadPendingReindexes(config2, state);
+  const pending = state.pendingReindexes.get(target.team.name) ?? [];
+  const change = pending.find((candidate) => candidate.relativePath === target.relativePath);
+  if (!change) {
+    const available = pending.filter(isShareableMemoryChange).map((candidate) => conflictId(target.team.name, candidate.relativePath));
+    throw new Error(
+      [
+        `No pending shared memory conflict found for ${conflictId(target.team.name, target.relativePath)}.`,
+        available.length > 0 ? `Pending conflicts for this team:
+${available.map((id) => `- ${id}`).join("\n")}` : `No pending conflicts for team "${target.team.name}".`
+      ].join("\n")
+    );
+  }
+  return { change: normalizePendingChange(target.team, change), team: target.team };
+}
+async function parseShareConflictReference(config2, reference, optionTeam) {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    throw new Error("Provide a conflict id, relative path, or viking:// shared memory URI.");
+  }
+  if (trimmed.startsWith("viking://")) {
+    const teamName = sharedTeamNameForUri(config2, trimmed);
+    if (!teamName) {
+      throw new Error(`Shared memory URI does not include a configured team: ${trimmed}`);
+    }
+    const team2 = await resolveTeam(config2, optionTeam ?? teamName);
+    return { relativePath: assertSafeShareRelativePath(vikingUriToWorktreeRelative(config2, trimmed, team2.name)), team: team2 };
+  }
+  const colon = trimmed.indexOf(":");
+  if (colon > 0 && !trimmed.slice(0, colon).includes("/")) {
+    const team2 = await resolveTeam(config2, optionTeam ?? trimmed.slice(0, colon));
+    return { relativePath: assertSafeShareRelativePath(trimmed.slice(colon + 1)), team: team2 };
+  }
+  const team = await resolveTeam(config2, optionTeam);
+  return { relativePath: assertSafeShareRelativePath(trimmed), team };
+}
+function assertSafeShareRelativePath(relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.split("/").some((segment) => segment === ".." || segment.length === 0)) {
+    throw new Error(`Invalid shared relative path: ${relativePath}`);
+  }
+  return relativePath;
+}
+function normalizePendingChange(team, change) {
+  return { ...change, path: (0, import_node_path3.join)(team.config.worktree, change.relativePath) };
+}
+function isShareableMemoryChange(change) {
+  const firstSegment = change.relativePath.split("/")[0];
+  return change.relativePath.endsWith(".md") && SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment);
+}
+async function buildShareConflictSummary(config2, team, change) {
+  const inspected = await inspectShareConflict(config2, team, change);
+  return {
+    hasLocalContent: inspected.hasLocalContent,
+    hasPreviousContent: inspected.hasPreviousContent,
+    hasSharedContent: inspected.hasSharedContent,
+    id: inspected.id,
+    reason: inspected.reason,
+    relativePath: inspected.relativePath,
+    status: inspected.status,
+    team: inspected.team,
+    uri: inspected.uri
+  };
+}
+async function inspectShareConflict(config2, team, change) {
+  const ov = await openVikingCliForMode(false);
+  const uri = workfileToVikingUri(config2, team.config, change.path);
+  const localContent = await readOptionalMemoryContent(config2, ov, uri);
+  const shared = await readOptionalSharedConflictContent(uri, change);
+  const previousContent = change.previousContent === void 0 ? void 0 : prepareSharedInboundContent(uri, change.previousContent);
+  return {
+    hasLocalContent: localContent !== void 0,
+    hasPreviousContent: previousContent !== void 0,
+    hasSharedContent: shared.content !== void 0,
+    id: conflictId(team.name, change.relativePath),
+    localContent,
+    previousContent,
+    reason: shareConflictReason(change, localContent, shared.content, previousContent, shared.error),
+    relativePath: change.relativePath,
+    sharedContent: shared.content,
+    status: change.status,
+    team: team.name,
+    uri
+  };
+}
+async function readOptionalSharedConflictContent(uri, change) {
+  try {
+    if (change.status === "removed" || !await isRegularFileNoSymlink(change.path)) {
+      return {};
+    }
+    return { content: await readSharedInboundFileContent(uri, change.path) };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function readOptionalMemoryContent(config2, ov, uri) {
+  if (!await vikingResourceExists(ov, config2, uri)) {
+    return void 0;
+  }
+  return readMemoryContent(config2, ov, uri, false);
+}
+function shareConflictReason(change, localContent, sharedContent, previousContent, sharedError) {
+  if (sharedError) {
+    return `shared file is not readable: ${sharedError}`;
+  }
+  if (change.status === "added") {
+    if (localContent === void 0) {
+      return "shared file is pending ingestion into OpenViking";
+    }
+    if (sharedContent === void 0) {
+      return "shared file is missing or not readable";
+    }
+    return sharedMemoryContentsEquivalent(localContent, sharedContent) ? "pending replay is already reflected in OpenViking" : "local OpenViking content differs from the newly added shared file";
+  }
+  if (change.status === "modified") {
+    if (localContent === void 0) {
+      return "OpenViking resource is missing while a shared update is pending";
+    }
+    if (previousContent === void 0) {
+      return "previous shared content is unavailable, so local edits cannot be distinguished from upstream edits";
+    }
+    return sharedMemoryContentsEquivalent(localContent, previousContent) ? "shared update is pending ingestion into OpenViking" : "local OpenViking content differs from the previous shared version";
+  }
+  if (localContent === void 0) {
+    return "shared deletion is already reflected in OpenViking";
+  }
+  if (previousContent === void 0) {
+    return "previous shared content is unavailable, so local deletion cannot be verified safely";
+  }
+  return sharedMemoryContentsEquivalent(localContent, previousContent) ? "shared deletion is pending removal from OpenViking" : "local OpenViking content differs from the deleted shared version";
+}
+async function conflictResolutionContent(conflict, take, fromFile, mergedContent) {
+  const raw = fromFile !== void 0 ? await (0, import_promises4.readFile)(expandPath(fromFile), "utf8") : mergedContent !== void 0 ? mergedContent : take === "local" ? conflict.localContent : void 0;
+  if (raw === void 0) {
+    throw new Error(`Cannot resolve ${conflict.id}: local OpenViking content is unavailable.`);
+  }
+  const scrub = applyScrubber(stripPersonalProvenance(raw), { redact: false });
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to resolve ${conflict.id}: possible ${scrub.blocker}. Strip the sensitive value before writing it to shared memory.`
+    );
+  }
+  return scrub.cleaned;
+}
+async function writeSharedConflictFile(team, conflict, content, dryRun) {
+  const filePath = (0, import_node_path3.join)(team.config.worktree, conflict.relativePath);
+  if (dryRun) {
+    console.log(`Would write shared file: ${portablePath(filePath)}`);
+    return;
+  }
+  await (0, import_promises4.mkdir)((0, import_node_path3.dirname)(filePath), { recursive: true });
+  await (0, import_promises4.writeFile)(filePath, content, "utf8");
+}
+async function backupShareConflict(config2, conflict) {
+  const backupDir = (0, import_node_path3.join)(
+    config2.agentContextHome,
+    "share",
+    "conflict-backups",
+    safeTimestamp(),
+    conflict.team,
+    ...conflict.relativePath.split("/")
+  );
+  await (0, import_promises4.mkdir)(backupDir, { recursive: true });
+  const metadata = {
+    id: conflict.id,
+    reason: conflict.reason,
+    relativePath: conflict.relativePath,
+    status: conflict.status,
+    team: conflict.team,
+    uri: conflict.uri
+  };
+  await (0, import_promises4.writeFile)((0, import_node_path3.join)(backupDir, "metadata.json"), `${JSON.stringify(metadata, void 0, 2)}
+`, "utf8");
+  if (conflict.localContent !== void 0) {
+    await (0, import_promises4.writeFile)((0, import_node_path3.join)(backupDir, "local.md"), conflict.localContent, "utf8");
+  }
+  if (conflict.sharedContent !== void 0) {
+    await (0, import_promises4.writeFile)((0, import_node_path3.join)(backupDir, "shared.md"), conflict.sharedContent, "utf8");
+  }
+  if (conflict.previousContent !== void 0) {
+    await (0, import_promises4.writeFile)((0, import_node_path3.join)(backupDir, "previous.md"), conflict.previousContent, "utf8");
+  }
+  return backupDir;
+}
+async function clearPendingShareConflict(config2, teamName, relativePath) {
+  const state = autoShareState(config2);
+  await loadPendingReindexes(config2, state);
+  const pending = state.pendingReindexes.get(teamName) ?? [];
+  const remaining = pending.filter((change) => change.relativePath !== relativePath);
+  if (remaining.length > 0) {
+    state.pendingReindexes.set(teamName, remaining);
+  } else {
+    state.pendingReindexes.delete(teamName);
+  }
+  await writePendingReindexes(config2, state);
+}
+function conflictId(team, relativePath) {
+  return `${team}:${relativePath}`;
+}
+function shareConflictResolutionGuidance(id) {
+  return [
+    `threadnote share conflict resolve ${id} --take shared`,
+    `threadnote share conflict resolve ${id} --take local`,
+    `threadnote share conflict resolve ${id} --from-file merged.md`
+  ];
+}
+function formatShareConflictDiff(conflict) {
+  const parts = [];
+  if (conflict.previousContent !== void 0) {
+    parts.push(
+      formatTwoWayDiff("previous shared", conflict.previousContent, "local OpenViking", conflict.localContent)
+    );
+  }
+  parts.push(formatTwoWayDiff("local OpenViking", conflict.localContent, "shared file", conflict.sharedContent));
+  return parts.join("\n\n");
+}
+function formatTwoWayDiff(leftLabel, leftContent, rightLabel, rightContent) {
+  if (leftContent === void 0 && rightContent === void 0) {
+    return `${leftLabel} and ${rightLabel} are both unavailable.`;
+  }
+  if (leftContent === rightContent) {
+    return `${leftLabel} and ${rightLabel} are identical.`;
+  }
+  const leftLines = splitDiffLines(leftContent);
+  const rightLines = splitDiffLines(rightContent);
+  const lines = [`--- ${leftLabel}`, `+++ ${rightLabel}`];
+  for (const line of leftLines) {
+    lines.push(`-${line}`);
+  }
+  for (const line of rightLines) {
+    lines.push(`+${line}`);
+  }
+  return lines.join("\n");
+}
+function splitDiffLines(content) {
+  if (content === void 0) {
+    return ["<missing>"];
+  }
+  const lines = content.split(/\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    return lines.slice(0, -1);
+  }
+  return lines;
+}
 async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
   const dryRun = options.dryRun === true;
   const push = options.push !== false;
@@ -39743,6 +40095,7 @@ async function main() {
         "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 scrubs for secrets, writes and pushes the shared copy first, then removes the personal copy after the push succeeds. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
+        'When recall/read reports pending shared memory conflicts, call `share_conflicts`, inspect one with `share_conflict_show`, then resolve it only after user direction with `share_conflict_resolve` using take="shared", take="local", or mergedContent.',
         "To share a local Codex/Claude skill or Claude command with teammates, call `share_skill` with the local file path. It publishes into the shared artifact catalog after the same scrubber checks.",
         "To use a team shared skill as a native local skill, call `list_shared_skills` first, then `install_shared_skill` for the selected name/agent/kind.",
         "Do not store secrets, customer data, raw production logs, or credentials."
@@ -39962,6 +40315,71 @@ function registerTools(server, config2) {
       return runSharePublishTool(config2, checkedUri.value, { message, preview, push, redact, team });
     }
   );
+  server.registerTool(
+    "share_conflicts",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "List pending shared memory conflicts left by share sync reindex failures. Use this when recall/read/sync reports pending shared memory conflicts. Each result includes a stable id plus exact next-step guidance for show/resolve.",
+      inputSchema: {
+        team: external_exports.string().optional().describe("Team name; omit to inspect all configured teams")
+      }
+    },
+    async ({ team }) => runShareConflictsTool(config2, { team })
+  );
+  server.registerTool(
+    "share_conflict_show",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Show one pending shared memory conflict, including local OpenViking content vs shared file diff and safe resolution options. The id comes from share_conflicts and has the form team:durable/projects/.../topic.md; a shared viking:// URI also works.",
+      inputSchema: {
+        id: external_exports.string().optional().describe("Required conflict id from share_conflicts, relative path plus team, or shared viking:// URI"),
+        team: external_exports.string().optional().describe("Team name when id is only a relative path")
+      }
+    },
+    async ({ id, team }) => {
+      const checkedId = requiredText(id, "share_conflict_show", "id", {
+        id: "default:durable/projects/foo/bar.md"
+      });
+      if (!checkedId.ok) {
+        return checkedId.error;
+      }
+      return runShareConflictShowTool(config2, checkedId.value, { team });
+    }
+  );
+  server.registerTool(
+    "share_conflict_resolve",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: 'Resolve one pending shared memory conflict on the user\u2019s behalf after they choose a winner. Use take="shared" to accept the shared git file into OpenViking, take="local" to publish local OpenViking content back to the shared repo, or mergedContent to write explicit merged markdown to both places. Creates a local backup before mutation and clears only the resolved pending entry.',
+      inputSchema: {
+        dryRun: external_exports.boolean().optional().describe("Preview without writing OpenViking, shared files, git commits, or pending state"),
+        id: external_exports.string().optional().describe("Required conflict id from share_conflicts, relative path plus team, or shared viking:// URI"),
+        mergedContent: external_exports.string().optional().describe(
+          "Explicit merged memory markdown. Mutually exclusive with take. MCP equivalent of CLI --from-file."
+        ),
+        message: external_exports.string().optional().describe("Commit message when writing local or merged content to the shared repo"),
+        push: external_exports.boolean().optional().describe("Push local/merged resolution commit to remote; defaults to true"),
+        take: external_exports.enum(["shared", "local"]).optional().describe("Resolution side. Mutually exclusive with mergedContent."),
+        team: external_exports.string().optional().describe("Team name when id is only a relative path")
+      }
+    },
+    async ({ dryRun, id, mergedContent, message, push, take, team }) => {
+      const checkedId = requiredText(id, "share_conflict_resolve", "id", {
+        id: "default:durable/projects/foo/bar.md"
+      });
+      if (!checkedId.ok) {
+        return checkedId.error;
+      }
+      return runShareConflictResolveTool(config2, checkedId.value, {
+        dryRun,
+        mergedContent,
+        message,
+        push,
+        take,
+        team
+      });
+    }
+  );
   server.registerTool(
     "share_skill",
     {
@@ -41489,6 +41907,85 @@ async function forgetVikingResourceWithRetry(config2, uri) {
   const ov = await requiredOpenVikingCli2();
   return removeVikingResourceWithRetry(ov, config2, uri);
 }
+async function runShareConflictsTool(config2, options) {
+  try {
+    const conflicts = await listShareConflicts(config2, options);
+    if (conflicts.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: options.team ? `No pending shared memory conflicts for team "${options.team}".` : "No pending shared memory conflicts."
+          }
+        ]
+      };
+    }
+    const lines = [`Pending shared memory conflicts: ${conflicts.length}`];
+    for (const conflict of conflicts) {
+      lines.push(
+        "",
+        conflict.id,
+        `uri: ${conflict.uri}`,
+        `status: ${conflict.status}`,
+        `reason: ${conflict.reason}`,
+        `show: share_conflict_show({"id":${JSON.stringify(conflict.id)}})`,
+        `take shared: share_conflict_resolve({"id":${JSON.stringify(conflict.id)},"take":"shared"})`,
+        `take local: share_conflict_resolve({"id":${JSON.stringify(conflict.id)},"take":"local"})`,
+        `merged: share_conflict_resolve({"id":${JSON.stringify(conflict.id)},"mergedContent":"<merged MEMORY markdown>"})`
+      );
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+async function runShareConflictShowTool(config2, id, options) {
+  try {
+    const detail = await showShareConflict(config2, id, options);
+    return {
+      content: [
+        {
+          type: "text",
+          text: [
+            `Conflict: ${detail.id}`,
+            `URI: ${detail.uri}`,
+            `Status: ${detail.status}`,
+            `Reason: ${detail.reason}`,
+            "",
+            detail.diff,
+            "",
+            "Resolve:",
+            `share_conflict_resolve({"id":${JSON.stringify(detail.id)},"take":"shared"})`,
+            `share_conflict_resolve({"id":${JSON.stringify(detail.id)},"take":"local"})`,
+            `share_conflict_resolve({"id":${JSON.stringify(detail.id)},"mergedContent":"<merged MEMORY markdown>"})`
+          ].join("\n")
+        }
+      ]
+    };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+async function runShareConflictResolveTool(config2, id, options) {
+  try {
+    const result = await resolveShareConflict(config2, id, {
+      dryRun: options.dryRun,
+      mergedContent: options.mergedContent,
+      message: options.message,
+      push: options.push,
+      take: options.take,
+      team: options.team
+    });
+    const lines = [...result.messages];
+    if (result.backupPath) {
+      lines.push(`Backup: ${result.backupPath}`);
+    }
+    lines.push(...result.gitMessages, `Resolved shared memory conflict: ${result.id}`);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
 async function runSharePublishTool(config2, sourceUri, options) {
   try {
     if (isInSharedNamespace(config2, sourceUri)) {

package/dist/threadnote.cjs

@@ -8902,7 +8902,35 @@ async function fetchShareUpdateStatuses(config) {
   return statuses;
 }
 async function runShareSync(config, options) {
-  const team = await resolveTeam(config, options.team);
+  const teams = await teamsForShareQuery(config, options.team);
+  if (options.team) {
+    const team = teams[0];
+    if (!team) {
+      throw new Error("No shared teams configured. Run: threadnote share init <remote-url>");
+    }
+    await runShareSyncForTeam(config, team, options);
+    return;
+  }
+  const failures = [];
+  for (const [index, team] of teams.entries()) {
+    if (teams.length > 1) {
+      console.log(`Syncing shared team "${team.name}" (${index + 1}/${teams.length})...`);
+    }
+    try {
+      await runShareSyncForTeam(config, team, options);
+    } catch (error) {
+      failures.push(`${team.name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (failures.length > 0) {
+    throw new Error(
+      [`share sync failed for ${failures.length} shared team(s):`, ...failures.map((failure2) => `- ${failure2}`)].join(
+        "\n"
+      )
+    );
+  }
+}
+async function runShareSyncForTeam(config, team, options) {
   const dryRun = options.dryRun === true;
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
@@ -8968,6 +8996,7 @@ Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or
         console.warn(
           `share sync: ${result.failed.length} file(s) could not be ingested on this run; they are persisted and will be retried on the next sync or agent recall/read.`
         );
+        console.warn(formatShareConflictNextSteps(team.name, result.failed));
       }
     }
   }
@@ -8982,13 +9011,152 @@ Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or
     }
   }
 }
+async function runShareConflicts(config, options) {
+  const conflicts = await listShareConflicts(config, options);
+  if (conflicts.length === 0) {
+    const team = options.team ? ` for team "${options.team}"` : "";
+    console.log(`No pending shared memory conflicts${team}.`);
+    return;
+  }
+  console.log(`Pending shared memory conflicts: ${conflicts.length}`);
+  for (const conflict of conflicts) {
+    console.log("");
+    console.log(`${conflict.id}`);
+    console.log(`  uri: ${conflict.uri}`);
+    console.log(`  status: ${conflict.status}`);
+    console.log(`  reason: ${conflict.reason}`);
+    console.log(`  show: threadnote share conflict show ${conflict.id}`);
+    console.log(`  take shared: threadnote share conflict resolve ${conflict.id} --take shared`);
+    console.log(`  take local: threadnote share conflict resolve ${conflict.id} --take local`);
+    console.log(`  merged file: threadnote share conflict resolve ${conflict.id} --from-file merged.md`);
+  }
+}
+async function runShareConflictShow(config, reference, options) {
+  const detail = await showShareConflict(config, reference, options);
+  console.log(`Conflict: ${detail.id}`);
+  console.log(`URI: ${detail.uri}`);
+  console.log(`Status: ${detail.status}`);
+  console.log(`Reason: ${detail.reason}`);
+  console.log("");
+  console.log(detail.diff);
+  console.log("");
+  console.log("Resolve:");
+  for (const line of detail.resolutionGuidance) {
+    console.log(`  ${line}`);
+  }
+}
+async function runShareConflictResolve(config, reference, options) {
+  const result = await resolveShareConflict(config, reference, options);
+  for (const message of result.messages) {
+    console.log(message);
+  }
+  if (result.backupPath) {
+    console.log(`Backup: ${portablePath(result.backupPath)}`);
+  }
+  for (const message of result.gitMessages) {
+    console.log(message);
+  }
+  console.log(`Resolved shared memory conflict: ${result.id}`);
+}
+async function listShareConflicts(config, options = {}) {
+  const teams = await teamsForShareQuery(config, options.team);
+  const state = autoShareState(config);
+  await loadPendingReindexes(config, state);
+  const summaries = [];
+  for (const team of teams) {
+    const pending = state.pendingReindexes.get(team.name) ?? [];
+    for (const change of pending) {
+      if (!isShareableMemoryChange(change)) {
+        continue;
+      }
+      summaries.push(await buildShareConflictSummary(config, team, normalizePendingChange(team, change)));
+    }
+  }
+  return summaries;
+}
+async function showShareConflict(config, reference, options = {}) {
+  const conflict = await readPendingShareConflict(config, reference, options.team);
+  const inspected = await inspectShareConflict(config, conflict.team, conflict.change);
+  return {
+    ...inspected,
+    diff: formatShareConflictDiff(inspected),
+    resolutionGuidance: shareConflictResolutionGuidance(inspected.id)
+  };
+}
+async function resolveShareConflict(config, reference, options) {
+  const fromFile = options.fromFile?.trim();
+  const mergedContent = options.mergedContent;
+  const rawTake = options.take;
+  if (rawTake !== void 0 && rawTake !== "shared" && rawTake !== "local") {
+    throw new Error(`Unsupported --take value "${rawTake}". Expected "shared" or "local".`);
+  }
+  const take = rawTake;
+  if ((take ? 1 : 0) + (fromFile ? 1 : 0) + (mergedContent !== void 0 ? 1 : 0) !== 1) {
+    throw new Error(
+      "Choose exactly one resolution: --take shared, --take local, --from-file <path>, or mergedContent via MCP."
+    );
+  }
+  const conflict = await readPendingShareConflict(config, reference, options.team);
+  const inspected = await inspectShareConflict(config, conflict.team, conflict.change);
+  const dryRun = options.dryRun === true;
+  const ov = await openVikingCliForMode(dryRun);
+  const messages = [];
+  const gitMessages = [];
+  const backupPath = dryRun ? void 0 : await backupShareConflict(config, inspected);
+  if (take === "shared") {
+    if (inspected.status === "removed") {
+      if (inspected.hasLocalContent) {
+        await removeMemoryUri(config, ov, inspected.uri, dryRun);
+        messages.push(`Accepted shared deletion for ${inspected.uri}.`);
+      } else {
+        messages.push(`Shared deletion was already reflected in OpenViking for ${inspected.uri}.`);
+      }
+    } else {
+      if (inspected.sharedContent === void 0) {
+        throw new Error(`Cannot take shared for ${inspected.id}: shared file is missing or not readable.`);
+      }
+      await ensureSharedDirectoryChain(config, ov, inspected.uri, dryRun);
+      await writeMemoryFile(
+        config,
+        ov,
+        inspected.uri,
+        inspected.sharedContent,
+        inspected.hasLocalContent ? "replace" : "create",
+        dryRun
+      );
+      messages.push(`Accepted shared file content for ${inspected.uri}.`);
+    }
+  } else {
+    const content = await conflictResolutionContent(inspected, take, fromFile, mergedContent);
+    await writeSharedConflictFile(conflict.team, inspected, content, dryRun);
+    await ensureSharedDirectoryChain(config, ov, inspected.uri, dryRun);
+    await writeMemoryFile(config, ov, inspected.uri, content, inspected.hasLocalContent ? "replace" : "create", dryRun);
+    const message = options.message ?? `share: resolve ${inspected.relativePath}`;
+    gitMessages.push(
+      ...await publishShareGitChange(conflict.team.config.worktree, inspected.relativePath, message, {
+        dryRun,
+        push: options.push
+      })
+    );
+    messages.push(
+      take === "local" ? `Published local OpenViking content for ${inspected.uri}.` : `Applied merged content for ${inspected.uri}.`
+    );
+  }
+  if (!dryRun) {
+    await clearPendingShareConflict(config, conflict.team.name, inspected.relativePath);
+  }
+  return { backupPath, gitMessages, id: inspected.id, messages, team: inspected.team, uri: inspected.uri };
+}
 async function runShareSyncQuiet(config, state, options) {
   const team = await resolveTeam(config, options.team);
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const pendingChanges = state.pendingReindexes.get(team.name);
   if (pendingChanges && pendingChanges.length > 0) {
-    await applyAndPersistChanges(config, team.config, state, pendingChanges, { quiet: true });
+    const result = await applyAndPersistChanges(config, team.config, state, pendingChanges, { quiet: true });
+    if (result.failed.length > 0) {
+      return `Shared team "${team.name}" has ${result.failed.length} pending shared memory conflict(s). Run \`threadnote share conflicts --team ${team.name}\` to inspect, then \`threadnote share conflict resolve <id> --take shared|local\` or \`--from-file <path>\`.`;
+    }
   }
   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.`;
@@ -9018,11 +9186,287 @@ async function runShareSyncQuiet(config, state, options) {
     if (changes.length > 0) {
       const stillPending = state.pendingReindexes.get(team.name) ?? [];
       const combined = mergeChanges(stillPending, changes);
-      await applyAndPersistChanges(config, team.config, state, combined, { quiet: true });
+      const result = await applyAndPersistChanges(config, team.config, state, combined, { quiet: true });
+      if (result.failed.length > 0) {
+        return `Shared team "${team.name}" has ${result.failed.length} pending shared memory conflict(s). Run \`threadnote share conflicts --team ${team.name}\` to inspect, then \`threadnote share conflict resolve <id> --take shared|local\` or \`--from-file <path>\`.`;
+      }
     }
   }
   return void 0;
 }
+async function teamsForShareQuery(config, teamName) {
+  if (teamName) {
+    return [await resolveTeam(config, teamName)];
+  }
+  const teams = await readTeamsFile(config);
+  const entries = Object.entries(teams.teams);
+  if (entries.length === 0) {
+    throw new Error("No shared teams configured. Run: threadnote share init <remote-url>");
+  }
+  return entries.map(([name, team]) => ({ config: team, name }));
+}
+async function readPendingShareConflict(config, reference, optionTeam) {
+  const target = await parseShareConflictReference(config, reference, optionTeam);
+  const state = autoShareState(config);
+  await loadPendingReindexes(config, state);
+  const pending = state.pendingReindexes.get(target.team.name) ?? [];
+  const change = pending.find((candidate) => candidate.relativePath === target.relativePath);
+  if (!change) {
+    const available = pending.filter(isShareableMemoryChange).map((candidate) => conflictId(target.team.name, candidate.relativePath));
+    throw new Error(
+      [
+        `No pending shared memory conflict found for ${conflictId(target.team.name, target.relativePath)}.`,
+        available.length > 0 ? `Pending conflicts for this team:
+${available.map((id) => `- ${id}`).join("\n")}` : `No pending conflicts for team "${target.team.name}".`
+      ].join("\n")
+    );
+  }
+  return { change: normalizePendingChange(target.team, change), team: target.team };
+}
+async function parseShareConflictReference(config, reference, optionTeam) {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    throw new Error("Provide a conflict id, relative path, or viking:// shared memory URI.");
+  }
+  if (trimmed.startsWith("viking://")) {
+    const teamName = sharedTeamNameForUri(config, trimmed);
+    if (!teamName) {
+      throw new Error(`Shared memory URI does not include a configured team: ${trimmed}`);
+    }
+    const team2 = await resolveTeam(config, optionTeam ?? teamName);
+    return { relativePath: assertSafeShareRelativePath(vikingUriToWorktreeRelative(config, trimmed, team2.name)), team: team2 };
+  }
+  const colon = trimmed.indexOf(":");
+  if (colon > 0 && !trimmed.slice(0, colon).includes("/")) {
+    const team2 = await resolveTeam(config, optionTeam ?? trimmed.slice(0, colon));
+    return { relativePath: assertSafeShareRelativePath(trimmed.slice(colon + 1)), team: team2 };
+  }
+  const team = await resolveTeam(config, optionTeam);
+  return { relativePath: assertSafeShareRelativePath(trimmed), team };
+}
+function assertSafeShareRelativePath(relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.split("/").some((segment) => segment === ".." || segment.length === 0)) {
+    throw new Error(`Invalid shared relative path: ${relativePath}`);
+  }
+  return relativePath;
+}
+function normalizePendingChange(team, change) {
+  return { ...change, path: (0, import_node_path7.join)(team.config.worktree, change.relativePath) };
+}
+function isShareableMemoryChange(change) {
+  const firstSegment = change.relativePath.split("/")[0];
+  return change.relativePath.endsWith(".md") && SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment);
+}
+async function buildShareConflictSummary(config, team, change) {
+  const inspected = await inspectShareConflict(config, team, change);
+  return {
+    hasLocalContent: inspected.hasLocalContent,
+    hasPreviousContent: inspected.hasPreviousContent,
+    hasSharedContent: inspected.hasSharedContent,
+    id: inspected.id,
+    reason: inspected.reason,
+    relativePath: inspected.relativePath,
+    status: inspected.status,
+    team: inspected.team,
+    uri: inspected.uri
+  };
+}
+async function inspectShareConflict(config, team, change) {
+  const ov = await openVikingCliForMode(false);
+  const uri = workfileToVikingUri(config, team.config, change.path);
+  const localContent = await readOptionalMemoryContent(config, ov, uri);
+  const shared = await readOptionalSharedConflictContent(uri, change);
+  const previousContent = change.previousContent === void 0 ? void 0 : prepareSharedInboundContent(uri, change.previousContent);
+  return {
+    hasLocalContent: localContent !== void 0,
+    hasPreviousContent: previousContent !== void 0,
+    hasSharedContent: shared.content !== void 0,
+    id: conflictId(team.name, change.relativePath),
+    localContent,
+    previousContent,
+    reason: shareConflictReason(change, localContent, shared.content, previousContent, shared.error),
+    relativePath: change.relativePath,
+    sharedContent: shared.content,
+    status: change.status,
+    team: team.name,
+    uri
+  };
+}
+async function readOptionalSharedConflictContent(uri, change) {
+  try {
+    if (change.status === "removed" || !await isRegularFileNoSymlink(change.path)) {
+      return {};
+    }
+    return { content: await readSharedInboundFileContent(uri, change.path) };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function readOptionalMemoryContent(config, ov, uri) {
+  if (!await vikingResourceExists(ov, config, uri)) {
+    return void 0;
+  }
+  return readMemoryContent(config, ov, uri, false);
+}
+function shareConflictReason(change, localContent, sharedContent, previousContent, sharedError) {
+  if (sharedError) {
+    return `shared file is not readable: ${sharedError}`;
+  }
+  if (change.status === "added") {
+    if (localContent === void 0) {
+      return "shared file is pending ingestion into OpenViking";
+    }
+    if (sharedContent === void 0) {
+      return "shared file is missing or not readable";
+    }
+    return sharedMemoryContentsEquivalent(localContent, sharedContent) ? "pending replay is already reflected in OpenViking" : "local OpenViking content differs from the newly added shared file";
+  }
+  if (change.status === "modified") {
+    if (localContent === void 0) {
+      return "OpenViking resource is missing while a shared update is pending";
+    }
+    if (previousContent === void 0) {
+      return "previous shared content is unavailable, so local edits cannot be distinguished from upstream edits";
+    }
+    return sharedMemoryContentsEquivalent(localContent, previousContent) ? "shared update is pending ingestion into OpenViking" : "local OpenViking content differs from the previous shared version";
+  }
+  if (localContent === void 0) {
+    return "shared deletion is already reflected in OpenViking";
+  }
+  if (previousContent === void 0) {
+    return "previous shared content is unavailable, so local deletion cannot be verified safely";
+  }
+  return sharedMemoryContentsEquivalent(localContent, previousContent) ? "shared deletion is pending removal from OpenViking" : "local OpenViking content differs from the deleted shared version";
+}
+async function conflictResolutionContent(conflict, take, fromFile, mergedContent) {
+  const raw = fromFile !== void 0 ? await (0, import_promises5.readFile)(expandPath(fromFile), "utf8") : mergedContent !== void 0 ? mergedContent : take === "local" ? conflict.localContent : void 0;
+  if (raw === void 0) {
+    throw new Error(`Cannot resolve ${conflict.id}: local OpenViking content is unavailable.`);
+  }
+  const scrub = applyScrubber(stripPersonalProvenance(raw), { redact: false });
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to resolve ${conflict.id}: possible ${scrub.blocker}. Strip the sensitive value before writing it to shared memory.`
+    );
+  }
+  return scrub.cleaned;
+}
+async function writeSharedConflictFile(team, conflict, content, dryRun) {
+  const filePath = (0, import_node_path7.join)(team.config.worktree, conflict.relativePath);
+  if (dryRun) {
+    console.log(`Would write shared file: ${portablePath(filePath)}`);
+    return;
+  }
+  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(filePath), { recursive: true });
+  await (0, import_promises5.writeFile)(filePath, content, "utf8");
+}
+async function backupShareConflict(config, conflict) {
+  const backupDir = (0, import_node_path7.join)(
+    config.agentContextHome,
+    "share",
+    "conflict-backups",
+    safeTimestamp(),
+    conflict.team,
+    ...conflict.relativePath.split("/")
+  );
+  await (0, import_promises5.mkdir)(backupDir, { recursive: true });
+  const metadata = {
+    id: conflict.id,
+    reason: conflict.reason,
+    relativePath: conflict.relativePath,
+    status: conflict.status,
+    team: conflict.team,
+    uri: conflict.uri
+  };
+  await (0, import_promises5.writeFile)((0, import_node_path7.join)(backupDir, "metadata.json"), `${JSON.stringify(metadata, void 0, 2)}
+`, "utf8");
+  if (conflict.localContent !== void 0) {
+    await (0, import_promises5.writeFile)((0, import_node_path7.join)(backupDir, "local.md"), conflict.localContent, "utf8");
+  }
+  if (conflict.sharedContent !== void 0) {
+    await (0, import_promises5.writeFile)((0, import_node_path7.join)(backupDir, "shared.md"), conflict.sharedContent, "utf8");
+  }
+  if (conflict.previousContent !== void 0) {
+    await (0, import_promises5.writeFile)((0, import_node_path7.join)(backupDir, "previous.md"), conflict.previousContent, "utf8");
+  }
+  return backupDir;
+}
+async function clearPendingShareConflict(config, teamName, relativePath) {
+  const state = autoShareState(config);
+  await loadPendingReindexes(config, state);
+  const pending = state.pendingReindexes.get(teamName) ?? [];
+  const remaining = pending.filter((change) => change.relativePath !== relativePath);
+  if (remaining.length > 0) {
+    state.pendingReindexes.set(teamName, remaining);
+  } else {
+    state.pendingReindexes.delete(teamName);
+  }
+  await writePendingReindexes(config, state);
+}
+function conflictId(team, relativePath) {
+  return `${team}:${relativePath}`;
+}
+function shareConflictResolutionGuidance(id) {
+  return [
+    `threadnote share conflict resolve ${id} --take shared`,
+    `threadnote share conflict resolve ${id} --take local`,
+    `threadnote share conflict resolve ${id} --from-file merged.md`
+  ];
+}
+function formatShareConflictNextSteps(teamName, changes) {
+  const ids = changes.filter(isShareableMemoryChange).map((change) => conflictId(teamName, change.relativePath));
+  if (ids.length === 0) {
+    return `Run \`threadnote share conflicts --team ${teamName}\` to inspect pending reindexes.`;
+  }
+  return [
+    `Resolve pending shared memory conflicts with:`,
+    `  threadnote share conflicts --team ${teamName}`,
+    ...ids.flatMap((id) => [
+      `  threadnote share conflict show ${id}`,
+      `  threadnote share conflict resolve ${id} --take shared`,
+      `  threadnote share conflict resolve ${id} --take local`,
+      `  threadnote share conflict resolve ${id} --from-file merged.md`
+    ])
+  ].join("\n");
+}
+function formatShareConflictDiff(conflict) {
+  const parts = [];
+  if (conflict.previousContent !== void 0) {
+    parts.push(
+      formatTwoWayDiff("previous shared", conflict.previousContent, "local OpenViking", conflict.localContent)
+    );
+  }
+  parts.push(formatTwoWayDiff("local OpenViking", conflict.localContent, "shared file", conflict.sharedContent));
+  return parts.join("\n\n");
+}
+function formatTwoWayDiff(leftLabel, leftContent, rightLabel, rightContent) {
+  if (leftContent === void 0 && rightContent === void 0) {
+    return `${leftLabel} and ${rightLabel} are both unavailable.`;
+  }
+  if (leftContent === rightContent) {
+    return `${leftLabel} and ${rightLabel} are identical.`;
+  }
+  const leftLines = splitDiffLines(leftContent);
+  const rightLines = splitDiffLines(rightContent);
+  const lines = [`--- ${leftLabel}`, `+++ ${rightLabel}`];
+  for (const line of leftLines) {
+    lines.push(`-${line}`);
+  }
+  for (const line of rightLines) {
+    lines.push(`+${line}`);
+  }
+  return lines.join("\n");
+}
+function splitDiffLines(content) {
+  if (content === void 0) {
+    return ["<missing>"];
+  }
+  const lines = content.split(/\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    return lines.slice(0, -1);
+  }
+  return lines;
+}
 async function stageShareableChanges(dryRun, git, worktree) {
   await removeOrphanPackIndexes(dryRun, git, worktree);
   const pathspecs = await existingShareablePathspecs(git, worktree);
@@ -17794,9 +18238,19 @@ async function main() {
   share.command("status").description("Show git status and ahead/behind counts for a shared team").option("--team <name>", "Team name; defaults to the configured default team").option("--dry-run", "Print git commands without running them").action(async (options) => {
     await runShareStatus(getRuntimeConfig(program2), options);
   });
-  share.command("sync").description("Pull, reindex, and push the shared memories repo for a team").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message when auto-committing local edits").option("--no-auto-commit", "Refuse to sync if there are uncommitted local changes").option("--no-push", "Skip the push step after pulling and reindexing").option("--dry-run", "Print actions without running them").action(async (options) => {
+  share.command("sync").description("Pull, reindex, and push shared memories repos").option("--team <name>", "Team name; when omitted, syncs all configured teams").option("--message <text>", "Commit message when auto-committing local edits").option("--no-auto-commit", "Refuse to sync if there are uncommitted local changes").option("--no-push", "Skip the push step after pulling and reindexing").option("--dry-run", "Print actions without running them").action(async (options) => {
     await runShareSync(getRuntimeConfig(program2), options);
   });
+  share.command("conflicts").description("List pending shared memory conflicts from failed share sync reindexes").option("--team <name>", "Team name; defaults to all configured teams").action(async (options) => {
+    await runShareConflicts(getRuntimeConfig(program2), options);
+  });
+  const shareConflict = share.command("conflict").description("Inspect or resolve one pending shared memory conflict");
+  shareConflict.command("show").description("Show local/shared content and resolution commands for one pending shared memory conflict").argument("<conflict-id>", "Conflict id from `threadnote share conflicts`, relative path, or shared viking:// URI").option("--team <name>", "Team name when conflict-id is a relative path").action(async (conflictId2, options) => {
+    await runShareConflictShow(getRuntimeConfig(program2), conflictId2, options);
+  });
+  shareConflict.command("resolve").description("Resolve one pending shared memory conflict with shared, local, or merged content").argument("<conflict-id>", "Conflict id from `threadnote share conflicts`, relative path, or shared viking:// URI").option("--team <name>", "Team name when conflict-id is a relative path").option("--take <side>", "Resolution side: shared or local").option("--from-file <path>", "Merged memory markdown to write to both OpenViking and the shared repo").option("--message <text>", "Commit message when writing local or merged content to the shared repo").option("--no-push", "Skip pushing a local/merged resolution commit").option("--dry-run", "Print actions without writing OpenViking, shared files, git commits, or pending state").action(async (conflictId2, options) => {
+    await runShareConflictResolve(getRuntimeConfig(program2), conflictId2, options);
+  });
   share.command("publish").description("Move a personal memory into the shared team namespace, commit and push").argument("<viking-uri>", "viking:// memory URI to publish").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message override").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").option(
     "--preview",
     "Print the exact bytes that would land in the shared git repo (after frontmatter strip and scrubber redaction) without writing, committing, or pushing"

package/docs/share.md

@@ -291,12 +291,13 @@ Manual sync remains useful when you want to publish local edits, clear a dirty
 shared worktree, resolve git conflicts, or force a sync immediately:
 
 ```bash
-threadnote share sync                  # default team
-threadnote share sync --team friends   # other team
-threadnote share sync --no-push        # pull only
+threadnote share sync                  # all configured teams
+threadnote share sync --team friends   # one team
+threadnote share sync --no-push        # pull only, all configured teams
 ```
 
-`share sync` will auto-commit edits in Threadnote-managed share paths, fetch and
+`share sync` without `--team` runs this flow for every configured team. For each
+team it will auto-commit edits in Threadnote-managed share paths, fetch and
 rebase onto the configured upstream, reindex pulled markdown files into
 OpenViking (so `recall` finds them immediately), and push. Managed share paths
 are root guidance/metadata files (`README.md`, `AGENTS.md`, `CLAUDE.md`,
@@ -397,6 +398,47 @@ upstream. When git can't merge cleanly:
 Two publishes touching the same `<topic>.md` from different machines will
 collide; coordinate ownership per-topic, or use distinct topics.
 
+### Resolve pending shared memory conflicts
+
+If `share sync` cannot safely reindex a shared memory into OpenViking, it keeps
+that file in the pending reindex queue and prints resolver commands. This is
+different from a git rebase conflict: the shared git worktree is clean, but the
+local OpenViking resource differs from the shared file or from the previous
+shared version.
+
+Inspect pending conflicts:
+
+```bash
+threadnote share conflicts
+threadnote share conflicts --team default
+threadnote share conflict show default:durable/projects/foo/bar.md
+```
+
+Resolve exactly one pending entry:
+
+```bash
+# Accept the shared git file into OpenViking. No git commit is made.
+threadnote share conflict resolve default:durable/projects/foo/bar.md --take shared
+
+# Publish the local OpenViking content back to the shared repo, then push.
+threadnote share conflict resolve default:durable/projects/foo/bar.md --take local
+
+# Write an explicit merge result to both OpenViking and the shared repo.
+threadnote share conflict resolve default:durable/projects/foo/bar.md --from-file merged.md
+```
+
+Each resolver writes a backup under
+`~/.openviking/share/conflict-backups/<timestamp>/...` before mutating local
+state. `--take shared` clears the pending item after updating or deleting the
+OpenViking resource. `--take local` and `--from-file` run the same scrubber as
+publish, commit the shared file, push by default, update OpenViking, and then
+clear only the resolved pending item. Pass `--no-push` to leave the resolution
+commit local.
+
+MCP agents have equivalent tools: `share_conflicts`, `share_conflict_show`, and
+`share_conflict_resolve`. `share_conflict_resolve` accepts `take:"shared"`,
+`take:"local"`, or `mergedContent:"..."`.
+
 ## Cross-machine identity notes
 
 Each user clones into their own user-namespaced path. A memory authored on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",