Conceptual job ${job.startIndex} died ${deaths} times unattr

Error message

Conceptual job ${job.startIndex} died ${deaths} times unattributably; quarantining items[0] (${firstPath}) as best-guess culprit.

What it means

When a conceptual job dies without an attributable file (the death could not be pinned to an excluded path) for the second time, the pool takes a best-guess: it quarantines items[0]'s path — that file is excluded from this run's indexing — and requeues the job's remainder with that path excluded. The warn names the job's startIndex, the quarantined path, and the death count.

Source

Thrown at gitnexus/src/core/ingestion/workers/worker-pool.ts:1718

      // (same `startIndex`), quarantine `items[0]` as a best-guess
      // culprit so the next attempt isn't condemned to the same death.
      // This bounds the unattributable-crash death loop and ensures the
      // pool's final `quarantinedPaths` snapshot carries SOME signal
      // for downstream diagnostics instead of silently re-hitting the
      // bad file.
      const requeueRemainder = (job: WorkerJob<TInput>, excluded: readonly string[]) => {
        let effectiveExcluded = excluded;
        if (excluded.length === 0) {
          const deaths = (unattributedJobDeaths.get(job.startIndex) ?? 0) + 1;
          unattributedJobDeaths.set(job.startIndex, deaths);
          if (deaths < 2) {
            jobs.unshift(job);
            return;
          }
          const firstPath = itemPath(job.items[0]);
          if (firstPath !== undefined) {
            quarantine.add(firstPath);
            logger.warn(
              { startIndex: job.startIndex, firstPath, deaths },
              `Conceptual job ${job.startIndex} died ${deaths} times unattributably; ` +
                `quarantining items[0] (${firstPath}) as best-guess culprit.`,
            );
            effectiveExcluded = [firstPath];
          } else {
            // No identifiable file on items[0] either — drop the job to
            // break the loop. The breaker counter still increments via
            // handleWorkerDeath, so consecutive unattributable deaths
            // eventually trip it even without quarantine signal.
            logger.warn(
              { startIndex: job.startIndex, deaths },
              `Conceptual job ${job.startIndex} died ${deaths} times unattributably with ` +
                `no identifiable file; dropping job to break the death loop.`,
            );
            return;
          }
        }

View on GitHub (pinned to 0d1aed942f)

Solutions

Read the quarantined path from the warn and inspect that file for parser-hostile content (huge generated code, pathological nesting)
If the file is legit and needed, try to reduce its size/complexness or report it upstream as a parser crash repro
Re-run analyze after fixing/excluding the file — quarantine is per-run state, so the next run retries it fresh
Watch the quarantine snapshot surfaced in any WorkerPoolDispatchError to confirm the loop actually converged

Defensive patterns

Strategy: fallback

Validate before calling

// Post-run: collect quarantined paths and act on them:
const quarantined = [...logText.matchAll(/quarantining items\[0\] \((.+?)\)/g)].map((m) => m[1]);
if (quarantined.length > 0) {
  writeLines('.gitnexusignore', quarantined); // or split/shrink each file
}

Prevention

Inspect any quarantined file for generated/pathological content before re-running
Remember quarantine is per-run: without a fix or ignore entry the same best-guess recurs
Keep WorkerPoolDispatchError's quarantine snapshot with your index logs — it is the converged culprit list

When it happens

Trigger: requeueRemainder called with an empty exclusion list after the same job.startIndex accumulated 2+ unattributable worker deaths (crashes with no in-flight file attribution); quarantine.add(firstPath) fires and the warn is logged.

Common situations: Native parser crashes triggered by a specific file but occurring after the in-flight tracking lost attribution, OOM deaths in sub-batch boundaries, or repro-crash files inside large jobs — the quarantine converges the loop at the cost of skipping one file.

Related errors

AI-assisted analysis of abhigyanpatwari/GitNexus@0d1aed942f (2026-08-20). Data as JSON: /api/errors/cf712c873fcb6e56. Report an issue: GitHub.