perf(sync): read the team's MCP history once per pull, in one git call (#993)

historicalContents read each historical blob with its own git process
(about 370 ms for 60 versions); it now reads them all with one
git cat-file --batch (about 30 ms). The MCP reconcile reads that history
once per run for every target, and only when a target file holds an
unrecorded entry; with no team server, nothing recorded and no server in
any target file it returns without reading it. A dry run names an
unrecorded copy of a server the team deleted that a pull would remove.

Author: SaulMoro

src/__tests__/e2e/config-entry-ownership-993.test.ts

@@ -261,6 +261,11 @@ describe('ownership of unrecorded MCP servers and hook entries (#993 bug 12)', (
     init(t, pulled, 'claude');
     removeMcpManifests();
     t.publish({ 'mcp/mcp.yaml': 'servers: []\n' }, 'drop');
+    const preview = pull(pulled, '--dry-run');
+    expect(preview.output).toContain(
+      `Would remove MCP server plain-api from ${path.join(pulled, '.mcp.json')}: it equals a server the team has removed.`,
+    );
+    expect(mcpServer(pulled, 'plain-api')).toEqual({ type: 'http', url: 'https://team.example.com/v1' });
     pull(pulled);
     expect(mcpServer(pulled, 'plain-api')).toBeUndefined();
 
@@ -282,6 +287,18 @@ describe('ownership of unrecorded MCP servers and hook entries (#993 bug 12)', (
     expect(mcpServer(dir, 'plain-api')).toEqual(mine);
   });
 
+  it('keeps a member\'s server whose name the team history never had', () => {
+    const t = team('never-team', { 'mcp/mcp.yaml': mcpYaml('https://team.example.com/v1') });
+    const mine = { type: 'http', url: 'https://mine.example.com/mcp' };
+    const dir = business('never-team-biz', { '.mcp.json': JSON.stringify({ mcpServers: { 'my-own': mine } }) });
+    init(t, dir, 'claude');
+    removeMcpManifests();
+    t.publish({ 'mcp/mcp.yaml': 'servers: []\n' }, 'drop');
+    pull(dir);
+    expect(mcpServer(dir, 'plain-api')).toBeUndefined();
+    expect(mcpServer(dir, 'my-own')).toEqual(mine);
+  });
+
   it('removes an unrecorded copy of a deleted server from Codex config too', () => {
     const t = team('removed-codex', { 'mcp/mcp.yaml': mcpYaml('https://team.example.com/v1') });
     const dir = business('removed-codex-biz', { '.codex/.keep': '' });

src/mcp-reconcile.ts

@@ -122,6 +122,11 @@ export interface McpChange {
 
 const UNRECORDED_SERVER_REASON = 'a server with this name already exists and is not managed by teamai';
 
+/** The dry-run line for an unrecorded copy of a server the team removed, which a run would remove (#993). */
+function describeRemovedServerPreview(target: McpTarget, name: string): string {
+  return `Would remove MCP server ${name} from ${target.file}: it equals a server the team has removed.`;
+}
+
 /** The dry-run line for an unrecorded server pull would record as teamai's without rewriting it (#993). */
 function describeAdoptionPreview(target: McpTarget, name: string): string {
   return `Would record MCP server ${name} in ${target.file} as teamai's: it already holds the team's ${name}.`;
@@ -726,13 +731,14 @@ function renderMcpEntry(
   return { entry: { entry, hash: entryHash(entry), resolvedValue }, passthrough };
 }
 
-/** Whether any revision of the team repo's MCP files defines a server (#993). Never for an HTTP-mode team. */
-async function teamMcpHistoryHasServers(localConfig: LocalConfig): Promise<boolean> {
-  if (localConfig.repo.kind === 'http') return false;
-  const layout = entryLayout('mcp');
-  const versions = await historicalContents(localConfig.repo.localPath, layout.dir);
-  return (versions ?? []).some((version) => path.posix.basename(version.path) === layout.file
-    && (parseTeamMcpServers(version.content.toString('utf8'))?.length ?? 0) > 0);
+/** Every revision of the team repo's MCP files (#993), or null when unreadable or an HTTP-mode team. */
+type TeamMcpHistory = Array<{ path: string; content: Buffer }> | null;
+
+/** The team's MCP history, read once, on first use. One per reconcile run, shared by every target. */
+function teamMcpHistory(localConfig: LocalConfig): () => Promise<TeamMcpHistory> {
+  return once(async () => (localConfig.repo.kind === 'http'
+    ? null
+    : historicalContents(localConfig.repo.localPath, entryLayout('mcp').dir)));
 }
 
 /** Whose an entry is that `target`'s own MCP record does not claim (#993). */
@@ -770,11 +776,11 @@ function judgeUnrecordedMcpEntry(
   desired: ReadonlyMap<string, DesiredMcpEntry>,
   vars: Record<string, string>,
   claimed: ReadonlySet<string>,
+  history: () => Promise<TeamMcpHistory> = teamMcpHistory(localConfig),
 ): McpEntryJudge {
   const renders = once(async (): Promise<Map<string, unknown[]> | null> => {
-    if (localConfig.repo.kind === 'http') return null;
     const layout = entryLayout('mcp');
-    const versions = await historicalContents(localConfig.repo.localPath, layout.dir);
+    const versions = await history();
     if (versions === null) return null;
     const entries = new Map<string, unknown[]>();
     for (const version of versions) {
@@ -978,6 +984,14 @@ export async function unclaimedMcpServers(target: McpTarget, claimed: readonly s
   return unclaimed.length === 0 || (await gitTracks(target.file)).kind === 'tracked' ? [] : unclaimed;
 }
 
+/** Whether any target's file holds an MCP server, recorded or not. */
+async function someMcpEntryInstalled(targets: readonly McpTarget[]): Promise<boolean> {
+  for (const target of targets) {
+    if (((await installedMcpEntries(target))?.size ?? 0) > 0) return true;
+  }
+  return false;
+}
+
 /** `load`, run once, on the first call. */
 function once<T>(load: () => Promise<T>): () => Promise<T> {
   let value: Promise<T> | undefined;
@@ -1833,9 +1847,10 @@ async function reconcileTargets(
   // An empty desired set still has to run: it is how servers dropped from
   // mcp.yaml get cleaned out of the tools we previously injected them into.
   const nothingOwned = Object.values(manifest).every((r) => r.length === 0);
-  // A server the team deleted can still sit unrecorded in a tool's file (#993): only a team
-  // history with no MCP server at all proves there is nothing to look for.
-  if (teamDefs.length === 0 && nothingOwned && !await teamMcpHistoryHasServers(localConfig)) return { changes, wrote };
+  // A server the team deleted can still sit unrecorded in a tool's file (#993): only target
+  // files with no server at all prove there is nothing to look for, without reading the history.
+  if (teamDefs.length === 0 && nothingOwned && !await someMcpEntryInstalled(targets)) return { changes, wrote };
+  const history = teamMcpHistory(localConfig);
   // The files an earlier pull recorded, and each record this run rebuilds after it was lost (#882).
   const ledger = localConfig.scope === 'project' && !options.dryRun ? (await readResolvedMcpFiles(localConfig)).files : {};
   const listed = new Set(Object.keys(ledger));
@@ -1864,7 +1879,7 @@ async function reconcileTargets(
     // Which of this team's servers apply to this tool, and in what rendered form.
     const { desired, skipped, kept } = desiredMcpForTarget(resolved, teamDefs, desiredContext);
     changes.push(...skipped);
-    const judge = judgeUnrecordedMcpEntry(localConfig, resolved, desired, desiredContext.vars, claimedByOtherTools(targets, resolved, manifest));
+    const judge = judgeUnrecordedMcpEntry(localConfig, resolved, desired, desiredContext.vars, claimedByOtherTools(targets, resolved, manifest), history);
     // A file an earlier teamai created that hides a later one, holding only teamai's servers, is left (#993).
     const leaving = removeAll ? null : await leaveFormerMcpFile(resolved, manifest[manifestKey] ?? [], judge);
     const target = leaving ? { ...resolved, file: leaving.next } : resolved;
@@ -2147,6 +2162,7 @@ async function applyJson(
   // server from the team history (#993), and goes like any other server teamai no longer delivers.
   for (const [name, entry] of Object.entries(doc.servers)) {
     if (desired.has(name) || ownedNames.has(name) || await judge(name, entry) !== 'teamai') continue;
+    if (options.dryRun) log.info(describeRemovedServerPreview(target, name));
     delete doc.servers[name];
     dirty = true;
     changes.push({ tool: target.tool, server: name, action: 'removed' });
@@ -2336,6 +2352,7 @@ async function applyCodex(
     if (desired.has(name) || ownedNames.has(name) || await judge(name, codexBlockIn(source, name)) !== 'teamai') continue;
     const next = spliceCodexBlock(source, name, null);
     if (next === source) continue;
+    if (options.dryRun) log.info(describeRemovedServerPreview(target, name));
     source = next;
     dirty = true;
     changes.push({ tool: target.tool, server: name, action: 'removed' });

src/utils/team-history.ts

@@ -1,3 +1,4 @@
+import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { createGit } from './git.js';
 import { log } from './logger.js';
@@ -113,10 +114,42 @@ export async function historicalContents(
 ): Promise<Array<HistoricalVersion & { content: Buffer }> | null> {
   const versions = await historicalVersions(repoPath, pathspec);
   if (versions === null) return null;
+  const blobs = await readBlobs(repoPath, [...new Set(versions.map((version) => version.blob))]);
   const contents: Array<HistoricalVersion & { content: Buffer }> = [];
   for (const version of versions) {
-    const content = await readBlob(repoPath, version.blob);
-    if (content !== null) contents.push({ ...version, content });
+    const content = blobs.get(version.blob);
+    if (content !== undefined) contents.push({ ...version, content });
   }
   return contents;
 }
+
+/**
+ * The bytes of each of `blobs` in `repoPath`, read by one `git cat-file --batch`
+ * rather than a git process per blob. A blob git does not have is left out.
+ */
+async function readBlobs(repoPath: string, blobs: readonly string[]): Promise<Map<string, Buffer>> {
+  const found = new Map<string, Buffer>();
+  if (blobs.length === 0) return found;
+  const out = await new Promise<Buffer | null>((resolve) => {
+    const child = execFile('git', ['-C', repoPath, 'cat-file', '--batch'], { encoding: 'buffer', maxBuffer: 256 * 1024 * 1024 },
+      (error, stdout) => resolve(error ? null : stdout));
+    child.stdin?.end(`${blobs.join('\n')}\n`);
+  });
+  if (out === null) {
+    log.debug(`Could not read ${blobs.length} historical blob(s) in ${repoPath}`);
+    return found;
+  }
+  // Each answer: `<id> <type> <size>\n<bytes>\n`, or `<id> missing\n`.
+  let at = 0;
+  while (at < out.length) {
+    const eol = out.indexOf(0x0a, at);
+    if (eol === -1) break;
+    const [id, type, size] = out.subarray(at, eol).toString('utf8').split(' ');
+    at = eol + 1;
+    if (type === 'missing' || size === undefined) continue;
+    const length = Number(size);
+    if (type === 'blob') found.set(id, Buffer.from(out.subarray(at, at + length)));
+    at += length + 1;
+  }
+  return found;
+}