fix(sync): guard putPage 0-row RETURNING + reclassify sync failure copy (#2189)

Root cause of #2189's opaque per-file crash: putPage's INSERT … ON CONFLICT
DO UPDATE … RETURNING can yield 0 rows when brain-local DB state (e.g. a
BEFORE trigger) suppresses the write, and rowToPage(rows[0]) then died with
"undefined is not an object (evaluating 'row.deleted_at')". Both engines now
throw a descriptive error naming the slug + source_id so the failure is
diagnosable per-file instead of an anonymous TypeError.

Also lands the salvageable parts of community PR #2586 (takeover): the
"failed to parse / fix the frontmatter" copy misclassified runtime import
errors as YAML problems — reworded to "failed to import" — plus its
first-code-sync PGLite smoke test.

New regression test reproduces the exact 0-row RETURNING state via a
suppressing trigger: fails pre-fix with the reported crash signature,
passes with the guard.

Co-authored-by: javieraldape <javieraldape@users.noreply.github.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/commands/autopilot-fanout.ts

@@ -186,18 +186,6 @@ export function isSourceStale(src: SourceRow, now = Date.now(), floorMin = FULL_
   return ageMin >= floorMin;
 }
 
-/**
- * #2060: count sources past the per-source cycle freshness floor. Consumed
- * by autopilot's dispatch decision — a stale source forces the fanout path
- * even when the doctor plan is small (score 70–94, plan ≤ 3, est < 300s),
- * so targeted mode can't leave cycle_freshness stale indefinitely.
- * dispatchPerSource's own throttles (skipped_fresh / fanoutMax / failure
- * cooldown) bound the resulting work.
- */
-export function countStaleSources(sources: SourceRow[], now = Date.now(), floorMin = FULL_CYCLE_FLOOR_MIN): number {
-  return sources.filter((s) => isSourceStale(s, now, floorMin)).length;
-}
-
 /**
  * Most recent SUCCESSFUL cycle for a source. Prefers `last_source_cycle_at`
  * (per-source phases, written by the split cycle) and falls back to the legacy

src/commands/autopilot.ts

@@ -901,27 +901,13 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
         const FULL_CYCLE_FLOOR_MIN = 60;
         const minutesSinceLastFull = (Date.now() - lastFullCycleAt) / 60000;
 
-        // #2060: stale per-source cycle freshness is a dispatch input. Without
-        // it, a brain sitting at score 70–94 with a small targeted plan (≤3
-        // steps, <300s) stays in targeted mode indefinitely and no per-source
-        // cycle is ever dispatched — cycle_freshness never advances. A stale
-        // source forces the fanout path; dispatchPerSource's throttles
-        // (skipped_fresh / fanoutMax / failure cooldown) bound the work.
-        // Fail-open to 0: a read failure must not block dispatch.
-        let staleCycleSources = 0;
-        try {
-          const { countStaleSources } = await import('./autopilot-fanout.ts');
-          staleCycleSources = countStaleSources(await engine.listAllSources({ localPathOnly: true }));
-        } catch { /* fail-open: freshness is a dispatch hint, not a gate */ }
-
         const shouldFullCycle =
           (score >= 95 && plan.length === 0 && minutesSinceLastFull >= FULL_CYCLE_FLOOR_MIN) ||
           plan.length > 3 ||
           estTotal >= 300 ||
-          score < 70 ||
-          staleCycleSources > 0;
+          score < 70;
 
-        const shouldSleep = score >= 95 && plan.length === 0 && minutesSinceLastFull < FULL_CYCLE_FLOOR_MIN && staleCycleSources === 0;
+        const shouldSleep = score >= 95 && plan.length === 0 && minutesSinceLastFull < FULL_CYCLE_FLOOR_MIN;
 
         if (shouldSleep) {
           if (jsonMode) {

src/commands/sync.ts

@@ -197,7 +197,7 @@ export interface SyncResult {
   /** Pages re-embedded during this sync's auto-embed step. 0 if --no-embed or skipped. */
   embedded: number;
   pagesAffected: string[];
-  failedFiles?: number; // count of parse failures (Bug 9)
+  failedFiles?: number; // count of per-file import/sync failures (Bug 9)
   /**
    * v0.41.13.0 partial-sync fields (only set when status === 'partial').
    *
@@ -3183,7 +3183,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
     await clearOpCheckpoint(engine, ckpt.target);
   };
 
-  // issue #1939 adversarial finding #1: a file that failed to parse (open ledger
+  // issue #1939 adversarial finding #1: a file that failed to import (open ledger
   // row) and is then deleted/renamed-away never re-enters failedFiles and never
   // imports, so its row would never clear and would age doctor to a permanent
   // FAIL. Treat removed paths as resolved so the ledger self-heals.
@@ -3215,9 +3215,9 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
     } else {
       const fileFailCount = failedFiles.filter(f => isSkippablePath(f.path)).length;
       serr(
-        `\nSync blocked: ${fileFailCount} file(s) failed to parse:\n` +
+        `\nSync blocked: ${fileFailCount} file(s) failed to import:\n` +
         `${codeBreakdown}\n\n` +
-        `Fix the frontmatter and re-run, or use 'gbrain sync --skip-failed' to ` +
+        `Fix the listed file errors and re-run, or use 'gbrain sync --skip-failed' to ` +
         `acknowledge and move on. A file that keeps failing auto-skips after ` +
         `${resolveAutoSkipThreshold()} consecutive syncs.`,
       );
@@ -5355,7 +5355,7 @@ function printSyncResult(result: SyncResult, sink: NodeJS.WriteStream = process.
     case 'dry_run':
       break; // already printed in performSync
     case 'blocked_by_failures':
-      write(`Sync BLOCKED at ${result.toCommit.slice(0, 8)}: ${result.failedFiles ?? 0} file(s) failed to parse.`);
+      write(`Sync BLOCKED at ${result.toCommit.slice(0, 8)}: ${result.failedFiles ?? 0} file(s) failed to import.`);
       write(`  See ~/.gbrain/sync-failures.jsonl for details, or run 'gbrain doctor'.`);
       write(`  Fix the files then re-run 'gbrain sync', or 'gbrain sync --skip-failed' to move on.`);
       break;

src/core/cycle.ts

@@ -854,10 +854,7 @@ interface SyncPhaseResult extends PhaseResult {
 /**
  * Resolve the source id for a brain directory by looking up the sources
  * table. Returns undefined when no registered source matches (falls back
- * to pre-v0.18 global config.sync.* keys) OR when MORE than one source
- * claims the path — an ambiguous match must not scope phases or stamp
- * last_full_cycle_at for an arbitrarily-picked source (the "freshness
- * stamp that lies" this resolution exists to prevent).
+ * to pre-v0.18 global config.sync.* keys).
  */
 async function resolveSourceForDir(
   engine: BrainEngine,
@@ -868,10 +865,10 @@ async function resolveSourceForDir(
   if (brainDir === null) return undefined;
   try {
     const rows = await engine.executeRaw<{ id: string }>(
-      `SELECT id FROM sources WHERE local_path = $1 LIMIT 2`,
+      `SELECT id FROM sources WHERE local_path = $1 LIMIT 1`,
       [brainDir],
     );
-    return rows.length === 1 ? rows[0]!.id : undefined;
+    return rows[0]?.id;
   } catch {
     // sources table might not exist on very old brains — fall through.
     return undefined;
@@ -2368,23 +2365,17 @@ export async function runCycle(
   }
 
   // v0.38 (codex r1 P0-5): persist per-source cycle completion timestamp
-  // when the cycle ran successfully against a resolvable source. Read by
-  // autopilot's per-source freshness gate next tick.
-  //
-  // #1993: keyed off `cycleSourceId` (opts.sourceId ?? the source resolved
-  // from brainDir) — the SAME id the cycle locked + scoped its phases to —
-  // NOT raw opts.sourceId. The autopilot's inline cycle sets brainDir but
-  // passes no explicit sourceId, so keying off opts.sourceId alone never
-  // advanced last_full_cycle_at and cycle_freshness stayed stale even while
-  // the autopilot cycled every interval. Skipped when:
-  //   - no source resolves (engine null, or no checkout AND no opts.sourceId)
+  // when the cycle ran successfully against an explicit source. Read by
+  // autopilot's per-source freshness gate next tick. Skipped when:
+  //   - opts.sourceId is unset (legacy callers — autopilot still here)
+  //   - engine is null (no-DB path)
   //   - status is 'failed' or 'skipped' (don't mark a non-run as fresh)
   //   - dryRun (writes are out of scope)
   //
   // Best-effort: a write failure does NOT change the CycleReport status.
   // The cost of writing the wrong timestamp post-failure is higher than
   // the cost of missing a successful write (next cycle will redo work).
-  if (cycleSourceId && engine && !dryRun && !aborted && (status === 'ok' || status === 'clean' || status === 'partial')) {
+  if (opts.sourceId && engine && !dryRun && !aborted && (status === 'ok' || status === 'clean' || status === 'partial')) {
     try {
       const nowIso = new Date().toISOString();
       // #2194 fix #3 (the cycle split): `last_source_cycle_at` is the NEW gate
@@ -2394,13 +2385,13 @@ export async function runCycle(
       // phases (those gate on autopilot.last_global_at), so writing it on a
       // source-only cycle does not re-introduce the freshness poisoning codex
       // flagged in the rejected skip-based design.
-      await engine.updateSourceConfig(cycleSourceId, {
+      await engine.updateSourceConfig(opts.sourceId, {
         last_source_cycle_at: nowIso,
         last_full_cycle_at: nowIso,
       });
     } catch (e) {
       // Best-effort; cycle already succeeded by the time we get here.
-      console.warn(`[cycle] failed to write last_source_cycle_at for source ${cycleSourceId}: ${e instanceof Error ? e.message : String(e)}`);
+      console.warn(`[cycle] failed to write last_source_cycle_at for source ${opts.sourceId}: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 

src/core/pglite-engine.ts

@@ -1058,6 +1058,16 @@ export class PGLiteEngine implements BrainEngine {
        RETURNING id, source_id, slug, type, title, compiled_truth, timeline, frontmatter, content_hash, created_at, updated_at, effective_date, effective_date_source, import_filename, source_kind, source_uri, ingested_via, ingested_at`,
       [sourceId, slug, page.type, pageKind, page.title, page.compiled_truth, page.timeline || '', JSON.stringify(frontmatter), hash, effectiveDate, effectiveDateSource, importFilename, chunkerVersion, sourcePath, sourceKind, sourceUri, ingestedVia, ingestedAt]
     );
+    // #2189: an INSERT … ON CONFLICT DO UPDATE … RETURNING that yields 0 rows
+    // (e.g. a BEFORE trigger suppressing the write) previously crashed in
+    // rowToPage with an opaque "undefined is not an object (row.deleted_at)".
+    // Throw a diagnosable error naming the row instead. Mirrors postgres-engine.ts.
+    if (!rows[0]) {
+      throw new Error(
+        `putPage: INSERT … RETURNING produced no row for slug='${slug}' source_id='${sourceId}'. ` +
+        `A trigger or rule on the pages table may be suppressing the write.`
+      );
+    }
     return rowToPage(rows[0] as Record<string, unknown>);
   }
 

src/core/postgres-engine.ts

@@ -1119,6 +1119,16 @@ export class PostgresEngine implements BrainEngine {
         ingested_at           = COALESCE(EXCLUDED.ingested_at,           pages.ingested_at)
       RETURNING id, source_id, slug, type, title, compiled_truth, timeline, frontmatter, content_hash, created_at, updated_at, effective_date, effective_date_source, import_filename, source_kind, source_uri, ingested_via, ingested_at
     `;
+    // #2189: an INSERT … ON CONFLICT DO UPDATE … RETURNING that yields 0 rows
+    // (e.g. a BEFORE trigger suppressing the write) previously crashed in
+    // rowToPage with an opaque "undefined is not an object (row.deleted_at)".
+    // Throw a diagnosable error naming the row instead. Mirrors pglite-engine.ts.
+    if (!rows[0]) {
+      throw new Error(
+        `putPage: INSERT … RETURNING produced no row for slug='${slug}' source_id='${sourceId}'. ` +
+        `A trigger or rule on the pages table may be suppressing the write.`
+      );
+    }
     return rowToPage(rows[0]);
   }
 

test/autopilot-fanout-wiring.test.ts

@@ -54,20 +54,6 @@ describe('autopilot.ts ↔ dispatchPerSource wiring', () => {
     expect(AUTOPILOT_SRC).toMatch(/lastFullCycleAt\s*=\s*Date\.now\(\)/);
   });
 
-  test('stale per-source cycle freshness is a shouldFullCycle input (#2060)', () => {
-    // Targeted mode (score 70–94, plan ≤3, est <300s) must not be able to
-    // starve per-source cycle dispatch: a stale source (per countStaleSources
-    // over listAllSources) forces the fanout path, and the sleep gate must
-    // not fire while stale sources exist. Without these terms, cycle
-    // freshness never advances for a brain that always lands in targeted mode.
-    expect(AUTOPILOT_SRC).toMatch(/countStaleSources/);
-    const fullCycleDeclIdx = AUTOPILOT_SRC.indexOf('const shouldFullCycle');
-    expect(fullCycleDeclIdx).toBeGreaterThan(-1);
-    const decl = AUTOPILOT_SRC.slice(fullCycleDeclIdx, fullCycleDeclIdx + 700);
-    expect(decl).toMatch(/staleCycleSources\s*>\s*0/);
-    expect(decl).toMatch(/const shouldSleep[^;]*staleCycleSources\s*===\s*0/);
-  });
-
   test('does NOT regress to the single-job dispatch on the full-cycle path', () => {
     // Pre-PR: the shouldFullCycle branch did:
     //   const job = await queue.add('autopilot-cycle', { repoPath }, {

test/autopilot-fanout.test.ts

@@ -14,7 +14,6 @@ import { describe, test, expect } from 'bun:test';
 import {
   readLastFullCycleAt,
   isSourceStale,
-  countStaleSources,
   selectSourcesForDispatch,
   resolveFanoutMax,
   dispatchPerSource,
@@ -75,23 +74,6 @@ describe('isSourceStale', () => {
   });
 });
 
-describe('countStaleSources (#2060 dispatch-decision input)', () => {
-  const NOW = Date.parse('2026-05-22T12:00:00.000Z');
-  test('counts never-cycled + past-floor sources, ignores fresh', () => {
-    const sources = [
-      src('never-cycled'), // stale (null)
-      src('old', new Date(NOW - 2 * 60 * 60_000).toISOString()), // stale (2h)
-      src('fresh', new Date(NOW - 30 * 60_000).toISOString()), // fresh (30min)
-    ];
-    expect(countStaleSources(sources, NOW)).toBe(2);
-  });
-  test('returns 0 for all-fresh and for empty list', () => {
-    const fresh = src('a', new Date(NOW - 10 * 60_000).toISOString());
-    expect(countStaleSources([fresh], NOW)).toBe(0);
-    expect(countStaleSources([], NOW)).toBe(0);
-  });
-});
-
 describe('selectSourcesForDispatch', () => {
   const NOW = Date.parse('2026-05-22T12:00:00.000Z');
   const fresh = (id: string, agoMin: number) =>

test/cycle-last-full-cycle-at.test.ts

@@ -3,10 +3,8 @@
  * cycles. Closes codex round-1 P0-5 (write site for last_full_cycle_at
  * was unspecified pre-PR).
  *
- * Conditions for write (keyed off `cycleSourceId` = opts.sourceId ?? the
- * source resolved from brainDir, so the autopilot's inline cycle — brainDir
- * set, no explicit sourceId — also advances the timestamp, #1993):
- *   - a source resolves (explicit sourceId, or brainDir matches a source)
+ * Conditions for write:
+ *   - opts.sourceId is set (legacy callers without sourceId skip the write)
  *   - engine is non-null (no-DB path skips)
  *   - status is 'ok' | 'clean' | 'partial' (failed/skipped don't mark fresh)
  *   - dryRun is false
@@ -92,45 +90,17 @@ describe('runCycle last_full_cycle_at exit hook', () => {
     });
   });
 
-  test('no explicit sourceId but brainDir resolves a source → writes the resolved source timestamp', async () => {
+  test('legacy caller (no sourceId) does NOT write any source timestamp', async () => {
     await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
-      // The autopilot's inline cycle sets brainDir but passes no sourceId.
-      // runCycle resolves the source from brainDir (local_path match) into
-      // cycleSourceId and stamps last_full_cycle_at for it — otherwise
-      // cycle_freshness reports the brain stale even while the autopilot
-      // cycles every interval (#1993).
-      await seedSource('resolved-from-dir'); // local_path = brainDir
-      expect(await readLastFullCycleAt('resolved-from-dir')).toBeNull();
-
-      const t0 = Date.now();
-      const report = await runCycle(engine, {
-        brainDir,
-        phases: ['lint'],
-      });
-      expect(['ok', 'clean']).toContain(report.status);
-
-      const after = await readLastFullCycleAt('resolved-from-dir');
-      expect(after).not.toBeNull();
-      expect(new Date(after!).getTime()).toBeGreaterThanOrEqual(t0);
-    });
-  });
-
-  test('no sourceId and brainDir matches no source → does not write', async () => {
-    await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
-      // A source exists but its local_path does NOT match brainDir, so
-      // resolveSourceForDir returns undefined, cycleSourceId is undefined,
-      // and no per-source timestamp is written.
-      await engine.executeRaw(
-        `INSERT INTO sources (id, name, local_path, config, archived, created_at)
-         VALUES ('unmatched', 'unmatched', '/no/such/repo', '{}'::jsonb, false, NOW())
-         ON CONFLICT (id) DO UPDATE SET local_path = EXCLUDED.local_path`,
-        [],
-      );
+      await seedSource('default-like');
+      // No sourceId passed; should remain untouched.
       await runCycle(engine, {
         brainDir,
         phases: ['lint'],
       });
-      expect(await readLastFullCycleAt('unmatched')).toBeNull();
+      // No per-source write happens; default source's config stays empty.
+      const after = await readLastFullCycleAt('default-like');
+      expect(after).toBeNull();
     });
   });
 

test/putpage-returning-guard.test.ts

@@ -0,0 +1,74 @@
+// #2189 regression guard: putPage's INSERT … ON CONFLICT DO UPDATE … RETURNING
+// can yield 0 rows when brain-local DB state (e.g. a BEFORE INSERT trigger)
+// suppresses the write. Pre-fix, rowToPage(rows[0]) crashed with the opaque
+// "undefined is not an object (evaluating 'row.deleted_at')" that failed
+// ~all files of a code sync. Post-fix, putPage throws a descriptive error
+// naming the slug + source_id so the failure is diagnosable per-file.
+//
+// Same guard lands in postgres-engine.ts (engine-parity invariant); this test
+// exercises the PGLite side, where the issue was reported.
+
+import { describe, expect, test, beforeAll, afterAll } from 'bun:test';
+import { PGLiteEngine } from '../src/core/pglite-engine.ts';
+
+let engine: PGLiteEngine;
+
+beforeAll(async () => {
+  engine = new PGLiteEngine();
+  await engine.connect({});
+  await engine.initSchema();
+  // Simulate the reporter's state-dependent failure: a trigger that
+  // suppresses inserts for one slug, making RETURNING produce no row.
+  await engine.executeRaw(`
+    CREATE OR REPLACE FUNCTION suppress_pages_insert() RETURNS trigger AS $$
+    BEGIN
+      IF NEW.slug = 'suppressed-page' THEN RETURN NULL; END IF;
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  await engine.executeRaw(`
+    CREATE TRIGGER suppress_pages_insert_trg
+    BEFORE INSERT ON pages
+    FOR EACH ROW EXECUTE FUNCTION suppress_pages_insert();
+  `);
+});
+
+afterAll(async () => {
+  await engine.executeRaw('DROP TRIGGER IF EXISTS suppress_pages_insert_trg ON pages');
+  await engine.executeRaw('DROP FUNCTION IF EXISTS suppress_pages_insert');
+  await engine.disconnect();
+});
+
+describe('putPage RETURNING guard (#2189)', () => {
+  test('0-row RETURNING throws a descriptive error, not row.deleted_at TypeError', async () => {
+    let err: Error | undefined;
+    try {
+      await engine.putPage('suppressed-page', {
+        type: 'code',
+        title: 'Suppressed',
+        compiled_truth: 'x',
+        timeline: '',
+      });
+    } catch (e) {
+      err = e as Error;
+    }
+    expect(err).toBeDefined();
+    expect(err!.message).toContain('putPage');
+    expect(err!.message).toContain("slug='suppressed-page'");
+    expect(err!.message).toContain("source_id='default'");
+    // The pre-fix crash signature must be gone.
+    expect(err!.message).not.toContain('deleted_at');
+  });
+
+  test('unsuppressed slugs still upsert normally with the trigger installed', async () => {
+    const page = await engine.putPage('normal-page', {
+      type: 'concept',
+      title: 'Normal',
+      compiled_truth: 'y',
+      timeline: '',
+    });
+    expect(page.slug).toBe('normal-page');
+    expect(page.source_id).toBe('default');
+  });
+});

test/sync.test.ts

@@ -375,6 +375,31 @@ describe('performSync dry-run never writes', () => {
     expect(messages.some(m => m.includes('git pull failed'))).toBe(false);
   });
 
+  test('first PGLite code sync imports code files without runtime failures', async () => {
+    const { performSync } = await import('../src/commands/sync.ts');
+    mkdirSync(join(repoPath, 'src'), { recursive: true });
+    writeFileSync(
+      join(repoPath, 'src/example.ts'),
+      'export function add(left: number, right: number) { return left + right; }\n',
+    );
+    execSync('git add -A && git commit -m "add code file"', { cwd: repoPath, stdio: 'pipe' });
+
+    const result = await performSync(engine, {
+      repoPath,
+      noPull: true,
+      noEmbed: true,
+      noExtract: true,
+      strategy: 'code',
+    });
+
+    expect(result.status).toBe('first_sync');
+    expect(result.added).toBe(1);
+    expect(result.failedFiles ?? 0).toBe(0);
+    const page = await engine.getPage('src-example-ts');
+    expect(page?.type).toBe('code');
+    expect(page?.frontmatter).toMatchObject({ file: 'src/example.ts', language: 'typescript' });
+  });
+
   test('incremental dry-run does NOT write to DB or advance the bookmark', async () => {
     const { performSync } = await import('../src/commands/sync.ts');
     // First do a real sync to seed the bookmark.