@aabadin/project-memory-context 0.1.0

package/src/setup-bootstrap.mjs

@@ -0,0 +1,131 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+
+import { ensureProjectMemoryContextDirs, writeJsonArtifact } from './artifacts.mjs';
+import { PMC_ENRICHMENT_CONFIG_FILE } from './enrichment-config.mjs';
+import { resolveConfigDirs } from './platform.mjs';
+
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'));
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return fallback;
+    throw error;
+  }
+}
+
+function buildMcpConfig(installState) {
+  return {
+    mcpServers: {
+      'agent-memory': {
+        command: 'npx',
+        args: ['-y', '@aabadin/agent-memory-mcp'],
+        env: {
+          MEMORY_DB_PATH: installState.memoryDbPath,
+          ...(installState.embeddingCachePath
+            ? { EMBEDDING_CACHE_PATH: installState.embeddingCachePath }
+            : {}),
+        },
+      },
+    },
+  };
+}
+
+async function writeMcpJson(projectRoot, installState) {
+  const mcpPath = join(projectRoot, '.mcp.json');
+  const existing = await readJson(mcpPath, {});
+  const merged = {
+    ...existing,
+    mcpServers: {
+      ...(existing.mcpServers ?? {}),
+      ...buildMcpConfig(installState).mcpServers,
+    },
+  };
+  await writeFile(mcpPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+  return mcpPath;
+}
+
+async function ensureAgentConfigRegistration(projectRoot, installState) {
+  const { projectConfig } = resolveConfigDirs(projectRoot);
+  const agentDir = basename(projectConfig);
+
+  if (agentDir === '.opencode') {
+    const configPath = join(projectConfig, 'opencode.json');
+    const config = await readJson(configPath, { $schema: 'https://opencode.ai/config.json' });
+    const existing = Array.isArray(config.plugin) ? config.plugin : [];
+    if (!existing.includes('@aabadin/project-memory-context')) {
+      config.plugin = [...existing, '@aabadin/project-memory-context'];
+    }
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    // Also write .mcp.json so agent-memory is available immediately
+    await writeMcpJson(projectRoot, installState);
+    return configPath;
+  }
+
+  if (agentDir === '.claude' || agentDir === '.cursor' || agentDir === '.pmc') {
+    // For Claude Code, Cursor, and generic PMC setups: write .mcp.json directly
+    const mcpPath = await writeMcpJson(projectRoot, installState);
+    // Also persist enrichment config
+    const enrichPath = join(projectConfig, PMC_ENRICHMENT_CONFIG_FILE);
+    const existingConfig = await readJson(enrichPath, {});
+    const config = {
+      ...existingConfig,
+      enrichment: {
+        ...existingConfig.enrichment,
+        localModel: {
+          ...existingConfig.enrichment?.localModel,
+          baseUrl: installState.ollamaBaseUrl,
+          model: installState.ollamaModel,
+        },
+      },
+    };
+    await mkdir(dirname(enrichPath), { recursive: true });
+    await writeFile(enrichPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return mcpPath;
+  }
+
+  // Fallback: no agent dir detected — write .mcp.json at project root
+  return writeMcpJson(projectRoot, installState);
+}
+
+async function copyTemplate(packageRoot, templateName, projectRoot) {
+  const source = join(packageRoot, 'templates', templateName);
+  const target = join(projectRoot, templateName);
+  const content = await readFile(source, 'utf8');
+  const rendered = content.replaceAll('__PMC_PACKAGE_ROOT__', packageRoot);
+  await writeFile(target, rendered, 'utf8');
+  return target;
+}
+
+export async function bootstrapProjectInstall({
+  projectRoot,
+  packageRoot,
+  ollamaBaseUrl,
+  ollamaModel,
+  embeddingCachePath,
+}) {
+  const dirs = await ensureProjectMemoryContextDirs(projectRoot);
+  const memoryDbPath = join(dirs.base, 'memory-db');
+  const installState = {
+    packageRoot,
+    ollamaBaseUrl,
+    ollamaModel,
+    memoryDbPath,
+    embeddingCachePath: embeddingCachePath ?? join(dirs.base, 'embedding-cache'),
+    installedAt: new Date().toISOString(),
+  };
+
+  await mkdir(memoryDbPath, { recursive: true });
+  await writeJsonArtifact(join(dirs.base, 'install.json'), installState);
+  const configPath = await ensureAgentConfigRegistration(projectRoot, installState);
+  const commandPath = await copyTemplate(packageRoot, 'project-memory-context.md', projectRoot);
+  const workflowPath = await copyTemplate(packageRoot, 'project-memory-context workflow.md', projectRoot);
+
+  return {
+    installState,
+    configPath,
+    commandPath,
+    workflowPath,
+  };
+}

package/src/symbol-extractor.mjs

@@ -0,0 +1,29 @@
+import { extractJsTsSymbols } from './extractors/js-ts-extractor.mjs';
+import { extractRegexSymbols, EXTENSION_TO_LANGUAGE } from './extractors/regex-extractor.mjs';
+import { buildSymbolKey } from './symbol-keys.mjs';
+
+const JS_TS_EXTENSIONS = new Set(['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts']);
+
+export function extractTopLevelSymbols({ filePath, content }) {
+  const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase();
+  if (JS_TS_EXTENSIONS.has(ext)) {
+    return extractJsTsSymbols({ filePath, content });
+  }
+  if (EXTENSION_TO_LANGUAGE.has(ext)) {
+    return extractRegexSymbols({ filePath, content });
+  }
+  return [];
+}
+
+export function buildEnrichmentWorklist({ symbols, symbolIndex }) {
+  return symbols.map((symbol) => {
+    const prior = symbolIndex[symbol.symbolKey];
+    const status = prior && prior.codeHash === symbol.codeHash ? 'enriched' : 'pending';
+    return {
+      ...symbol,
+      status,
+      memoryId: prior?.memoryId ?? null,
+      graphNodeId: symbol.graphNodeId ?? prior?.graphNodeId ?? null,
+    };
+  });
+}

package/src/symbol-index.mjs

@@ -0,0 +1,30 @@
+export function upsertSymbolIndexEntry(index, entry) {
+  return {
+    ...index,
+    [entry.symbolKey]: {
+      memoryId: entry.memoryId ?? null,
+      graphNodeId: entry.graphNodeId ?? null,
+      codeHash: entry.codeHash,
+      status: entry.status,
+      lastEnrichedAt: entry.lastEnrichedAt ?? null,
+    },
+  };
+}
+
+export function findGraphNodeIdByMemoryId(index, memoryId) {
+  for (const entry of Object.values(index)) {
+    if (entry.memoryId === memoryId) {
+      return entry.graphNodeId ?? null;
+    }
+  }
+  return null;
+}
+
+export function findMemoryIdByGraphNodeId(index, graphNodeId) {
+  for (const entry of Object.values(index)) {
+    if (entry.graphNodeId === graphNodeId) {
+      return entry.memoryId ?? null;
+    }
+  }
+  return null;
+}

package/src/symbol-keys.mjs

@@ -0,0 +1,28 @@
+function normalizePath(filePath) {
+  return String(filePath).replace(/\\/g, '/');
+}
+
+export function buildSymbolKey(symbol) {
+  const filePath = normalizePath(symbol.filePath);
+
+  if (symbol.language === 'csharp') {
+    return [
+      'csharp',
+      filePath,
+      symbol.namespace ?? 'global',
+      symbol.containerName ?? 'none',
+      symbol.kind,
+      symbol.name,
+      symbol.signature ?? '()',
+    ].join('|');
+  }
+
+  return [
+    symbol.language,
+    filePath,
+    symbol.kind,
+    symbol.exportScope ?? 'local',
+    symbol.name,
+    String(symbol.arity ?? 0),
+  ].join('|');
+}

package/src/sync-manifest.mjs

@@ -0,0 +1,119 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const MANIFEST_FILE = 'sync-manifest.json';
+const manifestWriteLocks = new Map();
+
+function manifestPath(enrichmentDir) {
+  return join(enrichmentDir, MANIFEST_FILE);
+}
+
+export async function readSyncManifest(enrichmentDir) {
+  try {
+    return JSON.parse(await readFile(manifestPath(enrichmentDir), 'utf8'));
+  } catch (error) {
+    if (error && error.code !== 'ENOENT') {
+      throw error;
+    }
+    return { entries: [] };
+  }
+}
+
+export async function writeSyncManifest(enrichmentDir, manifest) {
+  const path = manifestPath(enrichmentDir);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+
+async function withManifestLock(enrichmentDir, operation) {
+  const path = manifestPath(enrichmentDir);
+  const previous = manifestWriteLocks.get(path) ?? Promise.resolve();
+  const next = previous
+    .catch(() => {})
+    .then(operation);
+  manifestWriteLocks.set(path, next);
+
+  try {
+    return await next;
+  } finally {
+    if (manifestWriteLocks.get(path) === next) {
+      manifestWriteLocks.delete(path);
+    }
+  }
+}
+
+export function createSyncEntry({ action, keyTag, content, category, tags, source, symbolKey }) {
+  return {
+    id: randomUUID(),
+    action,
+    key_tag: keyTag,
+    content: content || null,
+    category: category || 'architecture',
+    tags: tags || [],
+    status: 'pending',
+    source: source || 'unknown',
+    symbolKey: symbolKey || null,
+    addedAt: new Date().toISOString(),
+    syncedAt: null,
+  };
+}
+
+export async function appendSyncEntry(enrichmentDir, entry) {
+  return withManifestLock(enrichmentDir, async () => {
+    const manifest = await readSyncManifest(enrichmentDir);
+    manifest.entries.push(entry);
+    await writeSyncManifest(enrichmentDir, manifest);
+    return entry;
+  });
+}
+
+export async function appendSyncEntries(enrichmentDir, entries) {
+  return withManifestLock(enrichmentDir, async () => {
+    const manifest = await readSyncManifest(enrichmentDir);
+    manifest.entries.push(...entries);
+    await writeSyncManifest(enrichmentDir, manifest);
+    return entries;
+  });
+}
+
+export function getPendingEntries(manifest) {
+  return manifest.entries.filter(e => e.status === 'pending');
+}
+
+export function getPendingUpserts(manifest) {
+  return manifest.entries.filter(e => e.status === 'pending' && e.action === 'upsert');
+}
+
+export function getPendingDeletes(manifest) {
+  return manifest.entries.filter(e => e.status === 'pending' && e.action === 'delete');
+}
+
+export async function markEntriesSynced(enrichmentDir, ids) {
+  await withManifestLock(enrichmentDir, async () => {
+    const manifest = await readSyncManifest(enrichmentDir);
+    const idSet = new Set(ids);
+    for (const entry of manifest.entries) {
+      if (idSet.has(entry.id)) {
+        entry.status = 'synced';
+        entry.syncedAt = new Date().toISOString();
+      }
+    }
+    await writeSyncManifest(enrichmentDir, manifest);
+  });
+}
+
+export async function removeSyncedEntries(enrichmentDir) {
+  return withManifestLock(enrichmentDir, async () => {
+    const manifest = await readSyncManifest(enrichmentDir);
+    manifest.entries = manifest.entries.filter(e => e.status !== 'synced');
+    await writeSyncManifest(enrichmentDir, manifest);
+    return manifest.entries.length;
+  });
+}
+
+export async function clearManifest(enrichmentDir) {
+  await withManifestLock(enrichmentDir, async () => {
+    await writeSyncManifest(enrichmentDir, { entries: [] });
+  });
+}

package/src/template-installer.mjs

@@ -0,0 +1,181 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export { detectAgentType } from './platform.mjs';
+
+export function renderTemplate(content, placeholders) {
+  return Object.entries(placeholders).reduce(
+    (text, [key, value]) => text.replaceAll(`{{${key}}}`, value),
+    content,
+  );
+}
+
+const SUPPORTED_AGENTS = new Set(['opencode', 'claude-code', 'cursor', 'generic']);
+
+function resolvePackageRoot() {
+  return join(dirname(fileURLToPath(import.meta.url)), '..');
+}
+
+async function loadBinNames(packageRoot) {
+  const packageJson = JSON.parse(await readFile(join(packageRoot, 'package.json'), 'utf8'));
+  return {
+    PMC_BIN: Object.keys(packageJson.bin ?? {})[0] ?? 'pmc',
+    AGENT_MEMORY_CMD: 'npx -y @aabadin/agent-memory-mcp',
+  };
+}
+
+async function buildPlaceholders(projectRoot, packageRoot) {
+  const binNames = await loadBinNames(packageRoot);
+  return {
+    ...binNames,
+    PROJECT_ROOT: projectRoot,
+    CONFIG_DIR: '.pmc',
+  };
+}
+
+async function readTemplate(packageRoot, templatePath) {
+  return readFile(join(packageRoot, 'templates', templatePath), 'utf8');
+}
+
+async function writeIfMissingOrForced(filePath, content, options = {}) {
+  const { force = false } = options;
+  if (!force && existsSync(filePath)) return false;
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, content, 'utf8');
+  return true;
+}
+
+function hasBlockMarker(content, marker) {
+  return content.includes(`<!-- pmc:${marker} -->`);
+}
+
+function replaceOrAppendBlock(content, marker, block) {
+  const open = `<!-- pmc:${marker} -->`;
+  const close = `<!-- /pmc:${marker} -->`;
+  const regex = new RegExp(`${open}[\\s\\S]*?${close}`, 'g');
+
+  if (regex.test(content)) {
+    return content.replace(regex, `${open}\n${block}\n${close}`);
+  }
+
+  return `${content}\n\n${open}\n${block}\n${close}\n`;
+}
+
+function stripBlockMarkers(content, marker) {
+  return content
+    .replace(new RegExp(`<!-- pmc:${marker} -->|<!-- /pmc:${marker} -->`, 'g'), '')
+    .trim();
+}
+
+async function installWithBlockMarker({ projectRoot, packageRoot, placeholders, targetFile, templatePath, marker = 'init' }) {
+  const targetPath = join(projectRoot, targetFile);
+  const snippet = renderTemplate(await readTemplate(packageRoot, templatePath), placeholders);
+
+  let existing = '';
+  if (existsSync(targetPath)) {
+    existing = await readFile(targetPath, 'utf8');
+  }
+
+  if (hasBlockMarker(existing, marker)) {
+    const updated = replaceOrAppendBlock(existing, marker, stripBlockMarkers(snippet, marker));
+    await writeFile(targetPath, updated, 'utf8');
+    return;
+  }
+
+  await writeFile(targetPath, snippet, 'utf8');
+}
+
+async function installOpencode({ projectRoot, packageRoot, placeholders, globalConfigDir }) {
+  const globalDir = globalConfigDir;
+
+  const commandTemplates = [
+    'opencode/commands/new-project.md',
+    'opencode/commands/get-context.md',
+    'opencode/commands/sync-context.md',
+    'opencode/commands/sanitize.md',
+  ];
+
+  for (const tpl of commandTemplates) {
+    const rendered = renderTemplate(await readTemplate(packageRoot, tpl), placeholders);
+    const fileName = tpl.split('/').at(-1);
+    await writeIfMissingOrForced(join(globalDir, 'commands', fileName), rendered, { force: true });
+  }
+
+  const enrichTemplate = renderTemplate(
+    await readTemplate(packageRoot, 'opencode/agent/enrich.md'),
+    placeholders,
+  );
+  await writeIfMissingOrForced(join(globalDir, 'agent', 'enrich.md'), enrichTemplate, { force: true });
+
+  const agentsMdPath = join(projectRoot, 'AGENTS.md');
+  const autostartBlock = renderTemplate(
+    await readTemplate(packageRoot, 'opencode/autostart-snippet.md'),
+    placeholders,
+  );
+
+  let existing = '';
+  if (existsSync(agentsMdPath)) {
+    existing = await readFile(agentsMdPath, 'utf8');
+  }
+
+  const updated = replaceOrAppendBlock(existing, 'autostart', autostartBlock.trim());
+  await writeFile(agentsMdPath, updated, 'utf8');
+}
+
+async function installClaudeCode({ projectRoot, packageRoot, placeholders }) {
+  await installWithBlockMarker({
+    packageRoot,
+    placeholders,
+    projectRoot,
+    targetFile: 'CLAUDE.md',
+    templatePath: 'claude-code/CLAUDE.md.snippet',
+  });
+}
+
+async function installCursor({ projectRoot, packageRoot, placeholders }) {
+  await installWithBlockMarker({
+    packageRoot,
+    placeholders,
+    projectRoot,
+    targetFile: '.cursorrules',
+    templatePath: 'cursor/.cursorrules.snippet',
+  });
+}
+
+async function installGeneric({ projectRoot, packageRoot, placeholders }) {
+  const readme = renderTemplate(
+    await readTemplate(packageRoot, 'generic/README-SETUP.md'),
+    placeholders,
+  );
+  await writeFile(join(projectRoot, 'README-SETUP.md'), readme, 'utf8');
+}
+
+const INSTALLERS = {
+  'claude-code': installClaudeCode,
+  cursor: installCursor,
+  generic: installGeneric,
+  opencode: installOpencode,
+};
+
+export async function installAgentTemplates({
+  projectRoot,
+  agent,
+  packageRoot,
+  globalConfigDir,
+}) {
+  if (!SUPPORTED_AGENTS.has(agent)) {
+    throw new Error(`Unsupported agent type: ${agent}. Supported: ${[...SUPPORTED_AGENTS].join(', ')}`);
+  }
+
+  const pkgRoot = packageRoot ?? resolvePackageRoot();
+  const placeholders = await buildPlaceholders(projectRoot, pkgRoot);
+
+  await INSTALLERS[agent]({
+    globalConfigDir: globalConfigDir ?? join(projectRoot, '.pmc'),
+    packageRoot: pkgRoot,
+    placeholders,
+    projectRoot,
+  });
+}

package/src/worklist-state.mjs

@@ -0,0 +1,12 @@
+export function updateWorklistEntry(worklist, symbolKey, updates) {
+  return (worklist ?? []).map((entry) => {
+    if (entry.symbolKey !== symbolKey) {
+      return entry;
+    }
+
+    return {
+      ...entry,
+      ...updates,
+    };
+  });
+}

package/templates/claude-code/CLAUDE.md.snippet

@@ -0,0 +1,36 @@
+# PMC Commands
+
+<!-- pmc:init -->
+
+When the user types `/new-project`, run:
+
+```bash
+{{PMC_BIN}} bootstrap . --all --enrich
+```
+
+When the user types `/get-context`, run:
+
+```bash
+{{PMC_BIN}} context . --refresh
+```
+
+When the user types `/sync-context`, process `.planning/project-memory-context/enrichment/sync-manifest.json` and upsert pending entries into `agent-memory`.
+
+When the user types `/sanitize`, run:
+
+```bash
+{{PMC_BIN}} sanitize .
+```
+
+## Session autostart
+
+When starting a session in a project with `.planning/project-memory-context/`:
+
+1. Check `.planning/project-memory-context/enrichment/worklist.json` for pending or stale entries.
+2. If pending/stale entries exist, launch background enrichment: `{{PMC_BIN}} enrich .`
+3. Check `.planning/project-memory-context/enrichment/sync-manifest.json` for pending entries.
+4. If sync-manifest has pending entries, inform the user: "PMC has {n} pending sync operations. Run `/sync-context` to apply them."
+5. Search agent-memory with `query: "project context overview"` to fetch base context.
+6. Remind the user: "Use `/get-context <target>` for structural deep-dive before reading files."
+
+<!-- /pmc:init -->

package/templates/cursor/.cursorrules.snippet

@@ -0,0 +1,36 @@
+# PMC Commands
+
+<!-- pmc:init -->
+
+When the user types "/new-project", run:
+
+```bash
+{{PMC_BIN}} bootstrap . --all --enrich
+```
+
+When the user types "/get-context", run:
+
+```bash
+{{PMC_BIN}} context . --refresh
+```
+
+When the user types "/sync-context", process `.planning/project-memory-context/enrichment/sync-manifest.json` and upsert pending entries into `agent-memory`.
+
+When the user types "/sanitize", run:
+
+```bash
+{{PMC_BIN}} sanitize .
+```
+
+## Session autostart
+
+When starting a session in a project with `.planning/project-memory-context/`:
+
+1. Check `.planning/project-memory-context/enrichment/worklist.json` for pending or stale entries.
+2. If pending/stale entries exist, launch background enrichment: `{{PMC_BIN}} enrich .`
+3. Check `.planning/project-memory-context/enrichment/sync-manifest.json` for pending entries.
+4. If sync-manifest has pending entries, inform the user: "PMC has {n} pending sync operations. Run /sync-context to apply them."
+5. Search agent-memory with query "project context overview" to fetch base context.
+6. Remind the user: "Use /get-context <target> for structural deep-dive before reading files."
+
+<!-- /pmc:init -->

package/templates/generic/README-SETUP.md

@@ -0,0 +1,53 @@
+# PMC Setup Guide
+
+This project uses PMC (Project Memory Context) for persistent structured memory.
+
+## Quick Start
+
+```bash
+# Bootstrap the project (graphify + worklist + base memories)
+{{PMC_BIN}} bootstrap . --all --enrich
+
+# Check enrichment status
+{{PMC_BIN}} status .
+
+# Run semantic enrichment for pending symbols
+{{PMC_BIN}} enrich .
+
+# Refresh project context memories
+{{PMC_BIN}} context . --refresh
+
+# Sanitize (re-run graphify, mark stale entries)
+{{PMC_BIN}} sanitize .
+```
+
+## How It Works
+
+1. **Bootstrap** runs `graphify` to map your codebase structure, extracts symbols, and creates an enrichment worklist.
+2. **Enrich** processes each symbol through a semantic enrichment pipeline (local model -> cloud API -> agent subagent fallback chain).
+3. **Sync** pushes enriched memories to `agent-memory-mcp` for persistent retrieval.
+4. **Context** materializes 9 base project-context memories (stack, architecture, dependencies, etc.).
+
+## Files
+
+- `.planning/project-memory-context/` — all PMC data lives here
+- `.planning/project-memory-context/enrichment/worklist.json` — symbol enrichment queue
+- `.planning/project-memory-context/enrichment/sync-manifest.json` — pending agent-memory upserts
+- `.planning/project-memory-context/graph/` — graphify output
+
+## Requirements
+
+- Node.js >= 18
+- Python + `graphifyy` (`pip install graphifyy`)
+- `{{AGENT_MEMORY_CMD}}` (optional, for persistent memory)
+
+## CLI Reference
+
+```
+{{PMC_BIN}} init [--agent opencode|claude-code|cursor|generic]
+{{PMC_BIN}} bootstrap [dir] [--all] [--enrich]
+{{PMC_BIN}} enrich [dir] [--concurrency N]
+{{PMC_BIN}} context [dir] [--refresh]
+{{PMC_BIN}} sanitize [dir]
+{{PMC_BIN}} status [dir]
+```

package/templates/opencode/agent/enrich.md

@@ -0,0 +1,28 @@
+---
+name: enrich
+description: Run batch semantic enrichment for pending symbols using the fallback chain.
+argument-hint: "[--concurrency N]"
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+<objective>
+Run batch semantic enrichment for all pending symbols in the worklist. Uses the fallback chain: local-model -> cloud-api -> agent-subagent.
+</objective>
+
+<execution>
+Run:
+
+```bash
+{{PMC_BIN}} enrich . --concurrency 3
+```
+
+Each symbol gets enriched with a semantic report describing responsibility, inputs, outputs, dependencies, and role. Results are persisted and the sync-manifest is updated.
+</execution>
+
+<success_criteria>
+- All pending symbols processed (enriched or marked as error)
+- Sync-manifest updated with new entries
+</success_criteria>