@aabadin/project-memory-context 0.2.3 → 0.2.5

package/cli/context.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { access } from 'node:fs/promises';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -22,7 +22,7 @@ export async function findProjectRoot(startDir = process.cwd()) {
 
   while (true) {
     const installPath = join(currentDir, '.planning', 'project-memory-context', 'install.json');
-    if (await fileExists(installPath)) {
+    if (existsSync(installPath)) {
       return currentDir;
     }
 
@@ -35,6 +35,23 @@ export async function findProjectRoot(startDir = process.cwd()) {
   }
 }
 
+async function markContext(projectRoot, nodeIds) {
+  if (!nodeIds || nodeIds.length === 0) return;
+  const trackerPath = join(projectRoot, '.planning', 'project-memory-context', 'context-tracker.json');
+  let tracker = { activeNodeIds: [] };
+  try {
+    if (existsSync(trackerPath)) {
+      tracker = JSON.parse(readFileSync(trackerPath, 'utf-8'));
+    }
+  } catch {}
+  const existing = new Set(tracker.activeNodeIds || []);
+  nodeIds.forEach((id) => existing.add(id));
+  tracker.activeNodeIds = [...existing];
+  const dir = dirname(trackerPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(trackerPath, JSON.stringify(tracker, null, 2));
+}
+
 export function parseArgs(args) {
   const DEPTH_VALUES = ['compact', 'extended', 'deep', 'disk'];
   const FOCUS_VALUES = ['dependencies', 'callers', 'containment', 'impact', 'all'];
@@ -190,12 +207,12 @@ export function buildRenderInput(engine, resolved, { depth, focus }) {
   };
 }
 
-export async function runTargetContext({ projectRoot, target, explicitMode, depth, focus }) {
-  const artifacts = await loadArtifacts(projectRoot);
+export async function runTargetContext({ projectRoot, target, explicitMode, depth, focus, artifacts }) {
+  const artfs = artifacts ?? await loadArtifacts(projectRoot);
   const engine = createQueryEngine({
-    graph: artifacts.graph,
-    symbolIndex: artifacts.symbolIndex,
-    worklist: artifacts.worklist,
+    graph: artfs.graph,
+    symbolIndex: artfs.symbolIndex,
+    worklist: artfs.worklist,
     enrichmentDir: join(projectRoot, '.planning', 'project-memory-context', 'enrichment'),
     projectSlug: 'project',
   });
@@ -205,7 +222,7 @@ export async function runTargetContext({ projectRoot, target, explicitMode, dept
   const input = buildRenderInput(engine, resolved, { depth, focus });
   const output = renderTargetContext(input);
 
-  return { output, resolved, input };
+  return { output, resolved, input, artifacts: artfs };
 }
 
 export async function runProjectContext(projectRoot = process.cwd(), refresh = false) {
@@ -301,7 +318,8 @@ export async function main(args = process.argv.slice(2)) {
     return 1;
   }
 
-  const { output } = await runTargetContext({
+  const artifacts = await loadArtifacts(projectRoot);
+  const { output, resolved } = await runTargetContext({
     projectRoot,
     target: parsed.target,
     explicitMode: parsed.explicitMode,
@@ -309,6 +327,17 @@ export async function main(args = process.argv.slice(2)) {
     focus: parsed.focus,
   });
 
+  const nodeIdsToMark = [];
+  if (resolved.symbolKey) {
+    const entry = artifacts.symbolIndex[resolved.symbolKey];
+    if (entry?.graphNodeId) nodeIdsToMark.push(entry.graphNodeId);
+  } else if (resolved.target && (resolved.mode === 'file' || resolved.mode === 'symbol-missing')) {
+    const fileNodeId = resolved.target.replace(/[/\\]/g, '_').replace(/[:.]/g, '_');
+    nodeIdsToMark.push(fileNodeId);
+  }
+
+  await markContext(projectRoot, nodeIdsToMark);
+
   console.log(output);
   return 0;
 }

package/cli/enrich-queue.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { open } from 'node:fs/promises';
 import { resolve, dirname, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
 
 import { appendProviderEvent, withRecordedAttempt } from '../src/enrichment-attempts.mjs';
 import { PMC_ENRICHMENT_CONFIG_FILE, resolveEnrichmentConfig } from '../src/enrichment-config.mjs';
@@ -571,6 +573,19 @@ async function main() {
     summary,
   });
 
+  const retryLaunch = await maybeLaunchRetryErrors({
+    projectRoot: PROJECT_ROOT,
+    enrichmentDir,
+    summary,
+    loadRetryState: async () => loadOptionalJson(resolve(enrichmentDir, 'retry-state.json')),
+  });
+
+  if (retryLaunch.launched) {
+    console.error(`[queue] Auto-launched retry-errors in background -> ${retryLaunch.stdoutPath}`);
+  } else if (retryLaunch.reason === 'already-running') {
+    console.error('[queue] Retry-errors already running; skipping second launch');
+  }
+
   console.log(JSON.stringify({
     complete: summary.pending === 0,
     total: worklist.length,
@@ -584,6 +599,59 @@ async function main() {
   }, null, 2));
 }
 
+export async function maybeLaunchRetryErrors({
+  projectRoot,
+  enrichmentDir,
+  summary,
+  loadRetryState = async () => null,
+  spawnRetryProcess = launchRetryProcess,
+}) {
+  if ((summary?.errors ?? 0) === 0) {
+    return { launched: false, reason: 'no-errors' };
+  }
+
+  const retryState = await loadRetryState();
+  if (retryState?.status === 'running') {
+    return { launched: false, reason: 'already-running', retryState };
+  }
+
+  const scriptPath = resolve(PROJECT_ROOT, 'tools/project-memory-context/cli/retry-errors.mjs');
+  const stdoutPath = resolve(enrichmentDir, 'retry-stdout.log');
+  const stderrPath = resolve(enrichmentDir, 'retry-stderr.log');
+  const startedAt = new Date().toISOString();
+  const pid = process.pid;
+
+  await writeRetryState({
+    enrichmentDir,
+    status: 'running',
+    pid,
+    projectRoot,
+    startedAt,
+    heartbeatAt: startedAt,
+  });
+
+  await spawnRetryProcess({ projectRoot, scriptPath, stdoutPath, stderrPath });
+  return { launched: true, reason: 'spawned', stdoutPath, stderrPath };
+}
+
+async function launchRetryProcess({ projectRoot, scriptPath, stdoutPath, stderrPath }) {
+  const stdout = await open(stdoutPath, 'a');
+  const stderr = await open(stderrPath, 'a');
+  const child = spawn(process.execPath, [scriptPath, projectRoot, '--concurrency', '1', '--timeout', String(TIMEOUT_MS)], {
+    detached: true,
+    stdio: ['ignore', stdout.fd, stderr.fd],
+    cwd: projectRoot,
+  });
+  child.unref();
+  stdout.close();
+  stderr.close();
+}
+
+export async function writeRetryState({ enrichmentDir, status, pid, projectRoot, startedAt, heartbeatAt, finishedAt = null, lastError = null }) {
+  const retryStateFile = resolve(enrichmentDir, 'retry-state.json');
+  await saveJson(retryStateFile, { status, pid, projectRoot, startedAt, heartbeatAt, finishedAt, lastError });
+}
+
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   main().catch(async (err) => {
     try {

package/cli/retry-errors.mjs

@@ -4,11 +4,13 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { resolve, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { appendProviderEvent, withRecordedAttempt } from '../src/enrichment-attempts.mjs';
+import { appendProviderEvent } from '../src/enrichment-attempts.mjs';
 import { resolveEnrichmentConfig, PMC_ENRICHMENT_CONFIG_FILE } from '../src/enrichment-config.mjs';
 import { runEnrichmentWithFallback } from '../src/enrichment-driver.mjs';
 import { createLocalModelProvider } from '../src/providers/local-model-provider.mjs';
+import { createCloudApiProvider } from '../src/providers/cloud-api-provider.mjs';
 import { appendSyncEntry, createSyncEntry } from '../src/sync-manifest.mjs';
+import { MAX_RETRY_ITERATIONS, runRetryLoop } from '../src/retry-errors-runner.mjs';
 import { homedir } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -52,11 +54,10 @@ async function buildSymbolPrompt(symbol, projectRoot, maxCodeLines = 80) {
 }
 
 function parseArgs(argv) {
-  const args = { concurrency: 4, timeoutMs: 600000, model: null, baseUrl: null, reportFile: null, limit: null };
+  const args = { timeoutMs: 600000, model: null, baseUrl: null, reportFile: null, limit: null };
   for (let i = 2; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === '--concurrency' && argv[i + 1]) { args.concurrency = parseInt(argv[++i], 10); }
-    else if (arg === '--timeout' && argv[i + 1]) { args.timeoutMs = parseInt(argv[++i], 10); }
+    if (arg === '--timeout' && argv[i + 1]) { args.timeoutMs = parseInt(argv[++i], 10); }
     else if (arg === '--model' && argv[i + 1]) { args.model = argv[++i]; }
     else if (arg === '--base-url' && argv[i + 1]) { args.baseUrl = argv[++i]; }
     else if (arg === '--report' && argv[i + 1]) { args.reportFile = argv[++i]; }
@@ -68,18 +69,17 @@ function parseArgs(argv) {
 
 function printHelp() {
   console.log(`
-PMC Retry Errors — Re-enriches symbols that failed using Ollama directly
+PMC Retry Errors — Re-enriches symbols that failed using full provider fallback chain
 
-Usage: node tools/project-memory-context/cli/retry-errors.mjs [options]
+Usage: node tools/project-memory-context/cli/retry-errors.mjs [options] [project-root]
 
 Options:
-  --concurrency N     Parallel slots (default: 4)
-  --timeout MS        Timeout per symbol in ms (default: 600000 = 10min)
-  --model NAME        Ollama model name (default: from config)
-  --base-url URL      Ollama base URL (default: http://localhost:11434)
-  --limit N           Only retry first N error entries (default: all)
-  --report PATH       Save JSON report to file (default: .planning/.../retry-report.json)
-  -h, --help          Show this help
+  --timeout MS    Timeout per symbol in ms (default: 600000 = 10min)
+  --model NAME    Ollama model name (default: from config)
+  --base-url URL  Ollama base URL (default: http://localhost:11434)
+  --limit N       Only retry first N error entries (default: all)
+  --report PATH   Save JSON report to file (default: .planning/.../retry-report.json)
+  -h, --help      Show this help
 `);
 }
 
@@ -121,8 +121,6 @@ async function main() {
   const globalConfig = await loadOptionalJson(resolve(homedir(), '.config', 'opencode', PMC_ENRICHMENT_CONFIG_FILE));
   let config = resolveEnrichmentConfig({ projectConfig, globalConfig, env: process.env });
 
-  config.preferredModes = ['local-model'];
-
   if (args.model) {
     config.localModel.model = args.model;
   }
@@ -132,219 +130,165 @@ async function main() {
 
   const projectSlug = process.env.PMC_PROJECT_SLUG || basename(projectRoot);
 
-  const providers = [createLocalModelProvider()];
+  const providers = [
+    createLocalModelProvider(),
+    createCloudApiProvider(),
+  ];
 
   console.error(`\n[retry] ═════════════════════════════════════════════════════`);
-  console.error(`[retry] Retrying ${errorEntries.length} error symbols`);
-  console.error(`[retry] Provider: ${config.localModel.provider} | Model: ${config.localModel.model}`);
-  console.error(`[retry] Base URL: ${config.localModel.baseUrl}`);
-  console.error(`[retry] Concurrency: ${args.concurrency} | Timeout: ${args.timeoutMs / 1000}s`);
+  console.error(`[retry] Retrying ${errorEntries.length} error symbols using full provider chain`);
+  console.error(`[retry] Local Model: ${config.localModel.provider} | ${config.localModel.model} @ ${config.localModel.baseUrl}`);
+  console.error(`[retry] Cloud API: ${config.cloudApi.provider} @ ${config.cloudApi.baseUrl}`);
+  console.error(`[retry] Max iterations: ${MAX_RETRY_ITERATIONS} | Timeout: ${args.timeoutMs / 1000}s`);
   console.error(`[retry] ═════════════════════════════════════════════════════\n`);
 
-  const report = {
-    startedAt: new Date().toISOString(),
-    config: { model: config.localModel.model, baseUrl: config.localModel.baseUrl, concurrency: args.concurrency, timeoutMs: args.timeoutMs },
-    previousErrors: {},
-    results: [],
-    summary: { succeeded: 0, failed: 0, skipped: 0 },
-  };
+  const retrySymbol = async (candidate, iteration) => {
+    const startTime = Date.now();
+    const entry = worklist.find(e => e.symbolKey === candidate.symbolKey);
+    if (!entry) return { status: 'failed', elapsedMs: 0, attempts: [], failureReason: 'not found in worklist' };
 
-  for (const entry of errorEntries) {
-    const lastLocalAttempt = (entry.attempts ?? []).find(a => a.mode === 'local-model');
-    report.previousErrors[entry.symbolKey] = {
-      name: entry.name,
-      filePath: entry.filePath,
-      kind: entry.kind,
-      previousError: entry.error,
-      localModelError: lastLocalAttempt?.errorMessage ?? null,
-      localModelErrorType: lastLocalAttempt?.errorType ?? null,
-      attemptCount: entry.attempts?.length ?? 0,
-    };
-  }
+    entry.status = 'pending';
+    delete entry.error;
+    delete entry.failedAt;
 
-  const queue = [...errorEntries];
-  const activeSlots = new Map();
-  const results = [];
-  let slotIdCounter = 0;
+    try {
+      const prompt = await buildSymbolPrompt(entry, projectRoot);
+      const result = await runEnrichmentWithFallback({
+        request: { prompt, timeoutMs: args.timeoutMs },
+        config,
+        providers,
+        env: process.env,
+      });
 
-  async function dispatchSlot() {
-    while (queue.length > 0) {
-      const entry = queue.shift();
+      const elapsed = Date.now() - startTime;
 
-      entry.status = 'pending';
-      delete entry.error;
-      delete entry.failedAt;
+      for (const attempt of result.attempts ?? []) {
+        await appendProviderEvent(enrichmentDir, { symbolKey: entry.symbolKey, name: entry.name, ...attempt });
+      }
 
-      const slotId = slotIdCounter++;
-      const startTime = Date.now();
+      if (result.status === 'succeeded') {
+        const memoryId = `queue-${safeKey(entry.symbolKey)}`;
+        const enrichedAt = new Date().toISOString();
+        const memoryFile = resolve(enrichmentDir, `${safeKey(entry.symbolKey)}.memory.json`);
 
-      activeSlots.set(slotId, { entry, startTime });
+        await saveJson(memoryFile, {
+          content: result.content,
+          category: 'architecture',
+          tags: ['symbol', entry.language, entry.kind, `project:${projectSlug}`, `file:${entry.filePath}`],
+        });
 
-      try {
-        const prompt = await buildSymbolPrompt(entry, projectRoot);
-        const result = await runEnrichmentWithFallback({
-          request: { prompt, timeoutMs: args.timeoutMs },
-          config,
-          providers,
-          env: process.env,
+        const newAttempts = [...(entry.attempts ?? []), ...(result.attempts ?? [])];
+        Object.assign(entry, {
+          status: 'enriched',
+          memoryId,
+          enrichedAt,
+          error: undefined,
+          failedAt: undefined,
+          attempts: newAttempts,
         });
 
-        const elapsed = Date.now() - startTime;
-        activeSlots.delete(slotId);
+        symbolIndex[entry.symbolKey] = {
+          memoryId,
+          graphNodeId: entry.graphNodeId ?? null,
+          codeHash: entry.codeHash,
+          status: 'enriched',
+          lastEnrichedAt: enrichedAt,
+        };
 
-        for (const attempt of result.attempts ?? []) {
-          await appendProviderEvent(enrichmentDir, { symbolKey: entry.symbolKey, name: entry.name, ...attempt });
+        try {
+          await appendSyncEntry(enrichmentDir, createSyncEntry({
+            action: 'upsert',
+            keyTag: `key:symbol:${safeKey(entry.symbolKey)}`,
+            content: `## ${entry.name}\n\n${result.content}`,
+            category: 'architecture',
+            tags: ['symbol', entry.language, entry.kind, `project:${projectSlug}`, `file:${entry.filePath}`, 'enriched-by-retry'],
+            source: 'retry-errors',
+            symbolKey: entry.symbolKey,
+          }));
+        } catch (syncErr) {
+          console.error(`[retry] WARN: sync append failed for ${entry.name}: ${syncErr.message}`);
         }
 
-        const reportEntry = {
-          symbolKey: entry.symbolKey,
-          name: entry.name,
-          filePath: entry.filePath,
-          kind: entry.kind,
-          language: entry.language,
-          elapsedMs: elapsed,
-          attempts: result.attempts ?? [],
-        };
+        console.error(`  [OK] iter ${iteration} | ${entry.name} (${entry.filePath}:${entry.range.startLine}) — ${Math.round(elapsed / 1000)}s`);
 
-        if (result.status === 'succeeded') {
-          const memoryId = `queue-${safeKey(entry.symbolKey)}`;
-          const enrichedAt = new Date().toISOString();
-          const memoryFile = resolve(enrichmentDir, `${safeKey(entry.symbolKey)}.memory.json`);
+        await saveJson(worklistFile, worklist);
+        await saveJson(symbolIndexFile, symbolIndex);
 
-          await saveJson(memoryFile, {
-            content: result.content,
-            category: 'architecture',
-            tags: ['symbol', entry.language, entry.kind, `project:${projectSlug}`, `file:${entry.filePath}`],
-          });
-
-          const newAttempts = [...(entry.attempts ?? []), ...(result.attempts ?? [])];
-          Object.assign(entry, {
-            status: 'enriched',
-            memoryId,
-            enrichedAt,
-            error: undefined,
-            failedAt: undefined,
-            attempts: newAttempts,
-            lastModeUsed: 'local-model',
-          });
-
-          symbolIndex[entry.symbolKey] = {
-            memoryId,
-            graphNodeId: entry.graphNodeId ?? null,
-            codeHash: entry.codeHash,
-            status: 'enriched',
-            lastEnrichedAt: enrichedAt,
-          };
-
-          try {
-            await appendSyncEntry(enrichmentDir, createSyncEntry({
-              action: 'upsert',
-              keyTag: `key:symbol:${safeKey(entry.symbolKey)}`,
-              content: `## ${entry.name}\n\n${result.content}`,
-              category: 'architecture',
-              tags: ['symbol', entry.language, entry.kind, `project:${projectSlug}`, `file:${entry.filePath}`, 'enriched-by-retry'],
-              source: 'retry-errors',
-              symbolKey: entry.symbolKey,
-            }));
-          } catch (syncErr) {
-            console.error(`[retry] WARN: sync append failed for ${entry.name}: ${syncErr.message}`);
-          }
-
-          reportEntry.status = 'succeeded';
-          reportEntry.contentPreview = result.content?.substring(0, 200);
-          reportEntry.memoryId = memoryId;
-          report.summary.succeeded++;
-
-          const done = report.summary.succeeded + report.summary.failed;
-          console.error(`  [OK] ${entry.name} (${entry.filePath}:${entry.range.startLine}) — ${Math.round(elapsed / 1000)}s [${done}/${errorEntries.length}]`);
-        } else {
-          const lastError = result.attempts?.find(a => a.errorMessage)?.errorMessage ?? 'all providers failed';
-
-          const newAttempts = [...(entry.attempts ?? []), ...(result.attempts ?? [])];
-          Object.assign(entry, {
-            status: 'error',
-            error: lastError,
-            failedAt: new Date().toISOString(),
-            attempts: newAttempts,
-          });
-
-          symbolIndex[entry.symbolKey] = {
-            memoryId: null,
-            graphNodeId: entry.graphNodeId ?? null,
-            codeHash: entry.codeHash,
-            status: 'error',
-            lastEnrichedAt: new Date().toISOString(),
-          };
-
-          reportEntry.status = 'failed';
-          reportEntry.failureReason = lastError;
-          report.summary.failed++;
-
-          const done = report.summary.succeeded + report.summary.failed;
-          console.error(`  [FAIL] ${entry.name} (${entry.filePath}:${entry.range.startLine}) — ${lastError} — ${Math.round(elapsed / 1000)}s [${done}/${errorEntries.length}]`);
-        }
+        return { status: 'succeeded', elapsedMs: elapsed, attempts: result.attempts ?? [], memoryId, contentPreview: result.content?.substring(0, 200) };
+      } else {
+        const lastError = result.attempts?.find(a => a.errorMessage)?.errorMessage ?? 'all providers failed';
+        const newAttempts = [...(entry.attempts ?? []), ...(result.attempts ?? [])];
+        Object.assign(entry, {
+          status: 'error',
+          error: lastError,
+          failedAt: new Date().toISOString(),
+          attempts: newAttempts,
+        });
 
-        results.push(reportEntry);
-      } catch (err) {
-        const elapsed = Date.now() - startTime;
-        activeSlots.delete(slotId);
-
-        entry.status = 'error';
-        entry.error = err.message;
-        entry.failedAt = new Date().toISOString();
-
-        const reportEntry = {
-          symbolKey: entry.symbolKey,
-          name: entry.name,
-          filePath: entry.filePath,
-          kind: entry.kind,
-          language: entry.language,
-          elapsedMs: elapsed,
-          status: 'failed',
-          failureReason: err.message,
-          attempts: [],
+        symbolIndex[entry.symbolKey] = {
+          memoryId: null,
+          graphNodeId: entry.graphNodeId ?? null,
+          codeHash: entry.codeHash,
+          status: 'error',
+          lastEnrichedAt: new Date().toISOString(),
         };
 
-        results.push(reportEntry);
-        report.summary.failed++;
+        console.error(`  [FAIL] iter ${iteration} | ${entry.name} — ${lastError} — ${Math.round(elapsed / 1000)}s`);
+
+        await saveJson(worklistFile, worklist);
+        await saveJson(symbolIndexFile, symbolIndex);
 
-        const done = report.summary.succeeded + report.summary.failed;
-        console.error(`  [ERR] ${entry.name} — ${err.message} — ${Math.round(elapsed / 1000)}s [${done}/${errorEntries.length}]`);
+        return { status: 'failed', elapsedMs: elapsed, attempts: result.attempts ?? [], failureReason: lastError };
       }
+    } catch (err) {
+      const elapsed = Date.now() - startTime;
+      entry.status = 'error';
+      entry.error = err.message;
+      entry.failedAt = new Date().toISOString();
+
+      console.error(`  [ERR] iter ${iteration} | ${entry.name} — ${err.message} — ${Math.round(elapsed / 1000)}s`);
 
       await saveJson(worklistFile, worklist);
       await saveJson(symbolIndexFile, symbolIndex);
-    }
-  }
 
-  const slots = [];
-  for (let i = 0; i < args.concurrency; i++) {
-    slots.push(dispatchSlot());
-  }
-  await Promise.all(slots);
+      return { status: 'failed', elapsedMs: elapsed, attempts: [], failureReason: err.message };
+    }
+  };
 
-  report.results = results;
-  report.finishedAt = new Date().toISOString();
-  report.totalElapsedMs = results.reduce((a, r) => a + (r.elapsedMs ?? 0), 0);
+  const startedAt = new Date().toISOString();
+  const result = await runRetryLoop({
+    worklist,
+    maxIterations: MAX_RETRY_ITERATIONS,
+    retrySymbol,
+  });
 
   const reportPath = args.reportFile || resolve(enrichmentDir, 'retry-report.json');
-  await saveJson(reportPath, report);
+  await saveJson(reportPath, {
+    startedAt,
+    finishedAt: new Date().toISOString(),
+    iterations: result.iterations,
+    config: { model: config.localModel.model, baseUrl: config.localModel.baseUrl, timeoutMs: args.timeoutMs },
+    symbols: result.symbols,
+    summary: result.summary,
+  });
 
   console.error(`\n[retry] ═════════════════════════════════════════════════════`);
-  console.error(`[retry] DONE — ${report.summary.succeeded} succeeded, ${report.summary.failed} failed, ${report.summary.skipped} skipped`);
+  console.error(`[retry] DONE — ${result.summary.symbolsRecovered} recovered, ${result.summary.symbolsStillFailing} still failing in ${result.iterations} iterations`);
   console.error(`[retry] Report: ${reportPath}`);
   console.error(`[retry] ═════════════════════════════════════════════════════\n`);
 
   console.log(JSON.stringify({
     ok: true,
     command: 'retry-errors',
-    total: errorEntries.length,
-    succeeded: report.summary.succeeded,
-    failed: report.summary.failed,
+    total: result.summary.symbolsRetried,
+    succeeded: result.summary.symbolsRecovered,
+    failed: result.summary.symbolsStillFailing,
+    iterations: result.iterations,
+    maxIterationsReached: result.summary.maxIterationsReached,
     reportPath,
   }, null, 2));
 
-  return report.summary.failed > 0 ? 1 : 0;
+  return result.summary.symbolsStillFailing > 0 ? 1 : 0;
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aabadin/project-memory-context",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Portable project memory context CLI — bootstraps semantic enrichment workflows for any AI coding agent.",
   "license": "GPL-3.0-or-later",
   "type": "module",

package/src/retry-errors-runner.mjs

@@ -0,0 +1,120 @@
+export const MAX_RETRY_ITERATIONS = 5;
+
+function collectPreviousErrors(entry) {
+  const fromAttempts = (entry.attempts ?? [])
+    .filter((attempt) => attempt.status === 'failed' && attempt.errorMessage)
+    .map((attempt) => ({
+      provider: attempt.provider ?? null,
+      errorType: attempt.errorType ?? null,
+      message: attempt.errorMessage,
+      failedAt: attempt.endedAt ?? attempt.startedAt ?? null,
+    }));
+
+  if (fromAttempts.length > 0) {
+    return fromAttempts;
+  }
+
+  return entry.error
+    ? [{ provider: null, errorType: null, message: entry.error, failedAt: entry.failedAt ?? null }]
+    : [];
+}
+
+export function collectRetryCandidates(worklist) {
+  const bySymbol = new Map();
+
+  for (const entry of worklist) {
+    if (entry.status !== 'error') continue;
+    const existing = bySymbol.get(entry.symbolKey);
+    const previousErrors = collectPreviousErrors(entry);
+
+    if (!existing) {
+      bySymbol.set(entry.symbolKey, {
+        ...entry,
+        previousErrors: [...previousErrors],
+      });
+      continue;
+    }
+
+    existing.previousErrors.push(...previousErrors);
+    if ((entry.attempts?.length ?? 0) >= (existing.attempts?.length ?? 0)) {
+      Object.assign(existing, entry, { previousErrors: existing.previousErrors });
+    }
+  }
+
+  return [...bySymbol.values()];
+}
+
+export function buildRetryState({ status, pid, projectRoot, startedAt, heartbeatAt, finishedAt = null, lastError = null }) {
+  return {
+    status,
+    pid,
+    projectRoot,
+    startedAt,
+    heartbeatAt,
+    finishedAt,
+    lastError,
+  };
+}
+
+export async function runRetryLoop({
+  worklist,
+  maxIterations = MAX_RETRY_ITERATIONS,
+  retrySymbol,
+}) {
+  const reportBySymbol = new Map(
+    collectRetryCandidates(worklist).map((candidate) => [
+      candidate.symbolKey,
+      {
+        symbolKey: candidate.symbolKey,
+        name: candidate.name,
+        filePath: candidate.filePath,
+        kind: candidate.kind,
+        language: candidate.language,
+        previousErrors: candidate.previousErrors,
+        iterationResults: [],
+        finalStatus: 'error',
+        memoryId: null,
+        contentPreview: null,
+      },
+    ]),
+  );
+
+  let iterations = 0;
+
+  while (iterations < maxIterations) {
+    const currentCandidates = collectRetryCandidates(worklist);
+    if (currentCandidates.length === 0) break;
+
+    iterations += 1;
+    for (const symbol of currentCandidates) {
+      const outcome = await retrySymbol(symbol, iterations);
+      const reportEntry = reportBySymbol.get(symbol.symbolKey);
+      reportEntry.iterationResults.push({ iteration: iterations, ...outcome });
+      reportEntry.finalStatus = outcome.status === 'succeeded' ? 'enriched' : 'error';
+      reportEntry.memoryId = outcome.memoryId ?? reportEntry.memoryId;
+      reportEntry.contentPreview = outcome.contentPreview ?? reportEntry.contentPreview;
+
+      if (outcome.status === 'succeeded') {
+        const worklistEntry = worklist.find((e) => e.symbolKey === symbol.symbolKey);
+        if (worklistEntry) {
+          worklistEntry.status = 'enriched';
+        }
+      }
+    }
+  }
+
+  const symbols = [...reportBySymbol.values()];
+  const symbolsRecovered = symbols.filter((item) => item.finalStatus === 'enriched').length;
+  const symbolsStillFailing = symbols.length - symbolsRecovered;
+
+  return {
+    iterations,
+    symbols,
+    summary: {
+      symbolsRetried: symbols.length,
+      symbolsRecovered,
+      symbolsStillFailing,
+      maxIterationsReached: symbolsStillFailing > 0 && iterations === maxIterations,
+    },
+  };
+}

package/templates/opencode/commands/retry-errors.md

@@ -1,31 +1,24 @@
 ---
 name: retry-errors
-description: Re-enrich symbols that previously failed using Ollama directly, with a detailed per-symbol report.
+description: Re-enrich symbols still in error status through PMC's fallback chain, with a per-symbol report.
 argument-hint: "[--limit N] [--model MODEL] [--concurrency N] [--timeout MS]"
 allowed-tools:
   - Bash
 ---
 
 <objective>
-Retry enrichment for all symbols currently in error status, using only the local Ollama provider. Generates a per-symbol report showing what each previous error was and whether the retry succeeded.
+Retry enrichment for symbols currently in error status, deduped by symbol, while preserving a per-symbol report of previous failures and retry outcomes.
 </objective>
 
 <execution>
 Run:
 
 ```bash
-{{PMC_BIN}} retry-errors . --model "qwen2.5-coder:14b" --concurrency 1 --timeout 300000
+{{PMC_BIN}} retry-errors . --concurrency 1 --timeout 300000
 ```
 
-Options:
-- `--limit N` — Only retry the first N error entries (useful for testing)
-- `--model MODEL` — Ollama model to use (default: from config)
-- `--concurrency N` — Parallel slots (recommended: 1 for Ollama)
-- `--timeout MS` — Timeout per symbol in ms (default: 600000 = 10min)
-- `--report PATH` — Custom path for the JSON report
-
-The command reads the worklist, finds all entries with `status: "error"`, and re-enriches them using only the local-model (Ollama) provider. A JSON report is saved to `.planning/project-memory-context/enrichment/retry-report.json` with:
+The command reads the worklist, retries each unique `symbolKey` through the configured fallback chain (`local-model -> cloud-api -> agent-subagent`), and stops when all symbols recover or 5 iterations complete. A JSON report is saved to `.planning/project-memory-context/enrichment/retry-report.json` with:
 - Previous error details for each symbol (error type, message, provider)
-- Retry result (succeeded/failed, elapsed time, content preview)
-- Overall summary counts
-</execution>
+- Retry result per iteration (succeeded/failed, elapsed time, content preview)
+- Overall summary: symbols retried, symbols recovered, symbols still failing, max iterations reached
+</execution>