Egonex-AI/Understand-Anything · error

No unresolved symbol files eligible for a targeted retry; in

Error message

No unresolved symbol files eligible for a targeted retry; inspect the symbol report

What it means

After re-validating symbols from scratch (never trusting old reports), the script checks whether there is actually anything to retry: if the report is ok or has zero unresolvedFiles, there are no eligible files for a targeted retry, so it throws. This guards against preparing empty retry batches that would silently do nothing.

Source

Thrown at understand-anything-plugin/skills/understand/prepare-symbol-retry.mjs:35

async function main() {
  if (process.argv.length !== 3) throw new Error('Usage: node prepare-symbol-retry.mjs <projectRoot>');
  const projectRoot = realpathSync(process.argv[2]);
  const intermediateDir = await getIntermediateDir(projectRoot);
  const { plan, baseline } = loadSymbolContext(projectRoot, intermediateDir);
  if (!['PARTIAL_UPDATE', 'ARCHITECTURE_UPDATE'].includes(plan.action)) {
    throw new Error('Symbol retry requires a partial or architecture incremental update');
  }
  const retryPath = join(intermediateDir, 'incremental-symbol-retry.json');
  if (existsSync(retryPath)) {
    const retry = readJson(retryPath);
    if (retry.baseCommit === plan.baseCommit && retry.headCommit === plan.headCommit && retry.attempt === 1) {
      throw new Error('Symbol retry already used for these commits; stop without advancing the baseline');
    }
  }
  // Do not trust an old report or a caller-supplied list of files to replace.
  const report = await validateIncrementalSymbols(projectRoot, { intermediateDir });
  if (report.ok || report.unresolvedFiles.length === 0) {
    throw new Error('No unresolved symbol files eligible for a targeted retry; inspect the symbol report');
  }
  const paths = new Set(report.unresolvedFiles);
  const changedFilesPath = join(intermediateDir, 'incremental-symbol-retry-files.json');
  const batchesPath = join(intermediateDir, 'incremental-symbol-retry-batches.json');
  atomicWriteJson(changedFilesPath, [...paths]);
  const skillDir = dirname(fileURLToPath(import.meta.url));
  const batching = spawnSync(process.execPath, [
    join(skillDir, 'compute-batches.mjs'), projectRoot,
    `--changed-files=${changedFilesPath}`, `--output=${batchesPath}`,
  ], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
  if (batching.stderr) process.stderr.write(batching.stderr);
  if (batching.status !== 0) throw new Error(`Retry batching failed: ${batching.error ?? batching.status}`);
  const batches = readJson(batchesPath).batches;
  const scheduled = batches.flatMap(batch => batch.files.map(file => file.path));
  if (JSON.stringify([...scheduled].sort()) !== JSON.stringify([...paths].sort())) {
    throw new Error('Retry batches do not cover exactly the affected files');
  }
  for (const batch of batches) {

View on GitHub (pinned to 07edf82a04)

Solutions

1. Inspect the symbol validation report in the intermediate directory — if report.ok is true, no retry is needed; proceed with the normal incremental flow.
2. Confirm the symbol failure still reproduces (re-run validate-incremental-symbols.mjs) before invoking the retry script.
3. If validation passes, continue with the standard incremental merge instead of forcing a retry.

Example fix

// before
node prepare-symbol-retry.mjs .
// Error: No unresolved symbol files eligible for a targeted retry; inspect the symbol report
// after: verification first
node validate-incremental-symbols.mjs .   # shows ok: true → skip retry, run normal update

import { execFileSync } from 'node:child_process';
const report = JSON.parse(execFileSync('node', ['validate-incremental-symbols.mjs', projectRoot, '--json']).toString());
if (report.ok || report.unresolvedFiles.length === 0) {
  console.log('No unresolved symbols; skip retry and run normal incremental update.');
}

const hasRetryableFiles = (report) =>
  Boolean(report) && !report.ok && Array.isArray(report.unresolvedFiles) && report.unresolvedFiles.length > 0;

try {
  await runRetry(projectRoot);
} catch (e) {
  if (e.message.includes('No unresolved symbol files eligible')) {
    // validation passed; continue the normal incremental flow
  } else throw e;
}

When it happens

Trigger: Running prepare-symbol-retry.mjs when the fresh validateIncrementalSymbols() run finds no unresolved files — e.g. the symbols recovered on their own, the previous failure was fixed by another means, or the unresolved list is empty because validation never recorded failures.

Common situations: A prior step already fixed the broken symbols; developer runs retry defensively without an actual failure; stale failure reports cleared by a rebuild between runs; validation succeeded this time because the offending file changed.

Understand the failure class

Background: EmptyResultError / "no results found": when an API or scraper succeeds but returns zero rows — this error's family across 9 libraries.

Related errors

• Invalid knowledge graph: ${result.fatal ?? "unknown error"}
• Invalid domain graph: ${result.fatal ?? "unknown error"}
• Freshness response was malformed
• Scan artifact does not match the required shape
• Import artifact does not match the required shape

AI-assisted analysis of Egonex-AI/Understand-Anything@07edf82a04 (2026-09-07). Data as JSON: /api/errors/e8a924bfd236c1f3. Report an issue: GitHub.