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

Error message

Conceptual job ${job.startIndex} died ${deaths} times unattributably with no identifiable file; dropping job to break the death loop.

What it means

The sibling of the items[0] quarantine path: when a conceptual job dies 2+ unattributable times AND items[0] has no identifiable file path (itemPath returns undefined), the pool cannot form a best-guess culprit. It drops the job entirely to break the death loop; the failure counter still increments so consecutive unattributable deaths eventually trip the circuit breaker.

Source

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

          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;
          }
        }
        const excludeSet = new Set(effectiveExcluded);
        const filtered = job.items.filter((item) => {
          const p = itemPath(item);
          return p === undefined || !excludeSet.has(p);
        });
        if (filtered.length === 0) return;
        jobs.unshift({
          startIndex: job.startIndex,
          items: filtered,
          estimatedBytes: filtered.reduce((sum, item) => sum + estimateItemBytes(item), 0),
          attempt: job.attempt,

View on GitHub (pinned to 0d1aed942f)

Solutions

If you drive the pool programmatically, ensure your items expose a path itemPath can resolve — an identifiable file enables quarantine instead of whole-job loss
Check whether the dropped job's inputs were pathless by construction and fix the producer so items carry paths
Watch the circuit breaker: repeated unattributable deaths still trip WorkerPoolDispatchError, which carries the quarantine snapshot for diagnosis
Report upstream with the item shape if standard inputs produced pathless items

Example fix

# before (programmatic pool use)
const items = [{ blob: '...' }];              // no path → job dropped on 2nd death
// after
const items = [{ path: '/abs/file.ts', blob: '...' }];  // itemPath resolves → quarantine can converge

Defensive patterns

Strategy: fallback

Validate before calling

// Programmatic pool users: guarantee every item is path-attributable.
const items = rawItems.filter((it) => typeof itemPath(it) === 'string');
if (items.length !== rawItems.length) {
  throw new Error('pathless items disable quarantine convergence (whole jobs get dropped)');
}

Type guard

function hasAttributablePath<T>(item: T): item is T & { path: string } {
  return typeof (item as { path?: unknown }).path === 'string' && (item as { path: string }).path.length > 0;
}

Prevention

When driving the pool with custom item types, always expose a resolvable path
Watch for repeated whole-job drops — they still count toward the circuit breaker, so silence means eventual hard failure
Report pathless standard items upstream; they should not occur with file-backed inputs

When it happens

Trigger: requeueRemainder with an empty exclusion, deaths >= 2, and itemPath(job.items[0]) === undefined — jobs whose first item carries no path (synthetic inputs or pathless items) hit this branch and the job is discarded with the warn.

Common situations: Programmatic pool usage with non-file inputs (custom item types lacking a recognizable path), edge-case batch construction after multiple splits leave pathless leading items, or API misuse where itemPath was not taught the custom item shape.

Related errors

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