test(dream): conform dream-dir-source-stamp to canonical PGLite isolation pattern

check:test-isolation R3/R4 flagged the new test file: engine was created
in beforeEach (outside beforeAll) and never disconnected in afterAll.
Switch to the canonical shared-engine pattern (beforeAll create,
beforeEach resetPgliteState, afterAll disconnect) per
test/helpers/reset-pglite.ts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

docs/guides/live-sync.md

@@ -21,17 +21,14 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host it is unreachable. When that happens gbrain now falls back to
-the pooler automatically (one stderr warning, then single-pool mode for the
-rest of the process) — but the pooler's ~2-min statement timeout can truncate
-very long migrations or bulk imports.
+IPv4-only host, reads work but sync **silently skips most pages**. This is the
+number one cause of "sync ran but nothing happened."
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
-`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
-entirely. Verify by running `gbrain sync` and checking that the page count in
-`gbrain stats` matches the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
+running `gbrain sync` and checking that the page count in `gbrain stats` matches
+the syncable file count in the repo.
 
 ### The Primitives
 

llms-full.txt

@@ -2720,17 +2720,14 @@ GBrain is tuned for the Supabase **Transaction pooler** (port 6543): it
 auto-disables prepared statements there and routes `engine.transaction()`
 (migrations, DDL, sync imports) to a derived **direct** connection
 (`db.<ref>.supabase.co:5432`). That direct host is IPv6-only, so on an
-IPv4-only host it is unreachable. When that happens gbrain now falls back to
-the pooler automatically (one stderr warning, then single-pool mode for the
-rest of the process) — but the pooler's ~2-min statement timeout can truncate
-very long migrations or bulk imports.
+IPv4-only host, reads work but sync **silently skips most pages**. This is the
+number one cause of "sync ran but nothing happened."
 
 Fix: make the direct connection reachable over IPv4. Either set
 `GBRAIN_DIRECT_DATABASE_URL` to the **Session pooler** string (port 5432 on the
-`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on.
-`GBRAIN_DISABLE_DIRECT_POOL=1` skips the direct pool (and the fallback warning)
-entirely. Verify by running `gbrain sync` and checking that the page count in
-`gbrain stats` matches the syncable file count in the repo.
+`pooler.supabase.com` host, IPv4), or enable Supabase's IPv4 add-on. Verify by
+running `gbrain sync` and checking that the page count in `gbrain stats` matches
+the syncable file count in the repo.
 
 ### The Primitives
 

src/commands/autopilot.ts

@@ -38,6 +38,7 @@ import { logSelfUpgrade } from '../core/audit/self-upgrade-audit.ts';
 import { detectInstallMethod } from './upgrade.ts';
 import { evaluateQuietHours } from '../core/minions/quiet-hours.ts';
 import { inspectLock } from '../core/db-lock.ts';
+import { registerCleanup } from '../core/process-cleanup.ts';
 
 /**
  * v0.37.7.0 #1162 — classify autopilot reconnect-loop errors.
@@ -433,6 +434,37 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
   let stopping = false;
   let childSupervisor: ChildWorkerSupervisor | null = null;
 
+  // #1872: graceful engine shutdown. On PGLite the cycle steps run INLINE in
+  // this process, so a hard `process.exit` mid-write (systemctl stop →
+  // SIGTERM) kills WASM Postgres with the WAL dirty and can corrupt the
+  // brain. Two exit paths must both close the engine:
+  //   - autopilot's own shutdown() below (owns SIGINT + internal stops like
+  //     max_crashes / cycle-failure-cap), and
+  //   - process-cleanup's SIGTERM handler (installed at cli.ts module load;
+  //     it runs the cleanup registry with a 3s deadline and then exits) —
+  //     which is why closeEngine is ALSO registered there.
+  // closeEngine aborts the in-flight inline cycle (runCycle checks the
+  // signal between phases and threads it into phase sub-work), gives it a
+  // short bounded window to wind down, then disconnects. PGLite's
+  // disconnect() drains the pending query and checkpoints before closing;
+  // a second call is a no-op (disconnect snapshots + nulls the handle), so
+  // both paths firing is safe.
+  const shutdownAbort = new AbortController();
+  let inflightInlineCycle: Promise<unknown> | null = null;
+  const closeEngine = async () => {
+    shutdownAbort.abort(new Error('autopilot shutdown'));
+    if (inflightInlineCycle) {
+      // ponytail: 2s cap keeps us inside process-cleanup's 3s deadline; a
+      // between-phase abort resolves instantly, a mid-phase one may not.
+      await Promise.race([
+        inflightInlineCycle.catch(() => { /* cycle errors already logged by the loop */ }),
+        new Promise((r) => setTimeout(r, 2_000)),
+      ]);
+    }
+    try { await engine.disconnect(); } catch { /* best-effort */ }
+  };
+  const deregisterEngineClose = registerCleanup('autopilot-engine-close', closeEngine);
+
   if (spawnManagedWorker) {
     const cliPath = resolveGbrainCliPath();
     // Cgroup-aware auto-sized RSS watchdog cap (issue #1678). The old flat
@@ -520,6 +552,10 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
         childSupervisor.killChild('SIGKILL');
       }
     }
+    // #1872: abort the in-flight inline cycle and close the engine BEFORE
+    // process.exit — a hard exit mid-write corrupts PGLite's WASM Postgres.
+    await closeEngine();
+    deregisterEngineClose();
     try { unlinkSync(lockPath); } catch { /* already gone */ }
     process.exit(0);
   };
@@ -1008,16 +1044,21 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
       // path's phase set). Now both converge on the same primitive.
       try {
         const { runCycle } = await import('../core/cycle.ts');
-        const report = await runCycle(engine, {
+        // #1872: track the promise so closeEngine can drain it on shutdown,
+        // and pass the abort signal so the cycle winds down between phases.
+        const cyclePromise = runCycle(engine, {
           brainDir: repoPath,
           // Autopilot daemon path: pulls by default (matches
           // pre-v0.17 autopilot behavior). CLI dream defaults false
           // for cron safety; that choice is scoped to dream only.
           pull: true,
+          signal: shutdownAbort.signal,
           yieldBetweenPhases: async () => {
             await new Promise(r => setImmediate(r));
           },
         });
+        inflightInlineCycle = cyclePromise;
+        const report = await cyclePromise.finally(() => { inflightInlineCycle = null; });
         // Only 'failed' (every attempted phase failed) trips the autopilot
         // circuit breaker. 'partial' means at least one phase warned or
         // failed while others ran — that's a soft signal, not a fatal

src/commands/dream.ts

@@ -26,6 +26,7 @@
 import type { BrainEngine } from '../core/engine.ts';
 import {
   runCycle,
+  resolveSourceForDir,
   ALL_PHASES,
   type CyclePhase,
   type CycleReport,
@@ -380,9 +381,9 @@ Options:
 
   --source <id>       Scope the cycle to one source so doctor's
                       cycle_freshness check sees a fresh stamp on
-                      completion. Without this, gbrain dream's
-                      timestamp never lands and federated brains
-                      see "stale cycle" forever.
+                      completion. When omitted, gbrain derives the
+                      source from --dir / the configured checkout
+                      when it matches a source's local_path (#1869).
   --source-id <id>    Alias for --source. Matches the v0.37.7.0+
                       naming used by import/extract/graph-query.
 
@@ -634,6 +635,25 @@ export async function runDream(engine: BrainEngine | null, args: string[]): Prom
     );
     process.exit(1);
   }
+
+  // #1869: a path-scoped run (--dir, or the configured sync.repo_path) whose
+  // directory matches a registered source's local_path IS that source's cycle
+  // — derive the source id so runCycle writes last_source_cycle_at /
+  // last_full_cycle_at on success and doctor's cycle_freshness check stops
+  // reading perpetually stale. Explicit --source still wins (resolved above).
+  // Fixed here at the command level, NOT in runCycle's stamp gate, so legacy
+  // global callers (autopilot-global-maintenance runs GLOBAL_PHASES with a
+  // brainDir and no sourceId) can't falsely stamp per-source freshness.
+  // A derived match on an archived source is skipped silently (falls back to
+  // legacy unscoped behavior) — stamping it would mask staleness on restore,
+  // mirroring the explicit --source archived guard above.
+  if (resolvedSourceId === undefined && engine !== null && brainDir !== null) {
+    const derived = await resolveSourceForDir(engine, brainDir);
+    if (derived !== undefined) {
+      const src = await fetchSource(engine, derived);
+      if (src?.archived !== true) resolvedSourceId = derived;
+    }
+  }
   // ─── issue #1678: bounded single-hold extract_atoms drain ──────────
   if (opts.drain) {
     if (engine === null) {

src/commands/init.ts

@@ -1078,9 +1078,6 @@ async function initPostgres(opts: {
     console.warn('  Direct connections are IPv6 only and fail in many environments.');
     console.warn('  Use the Transaction pooler connection string instead (port 6543):');
     console.warn('  Supabase Dashboard > Connect (top bar) > Connection String > Transaction pooler');
-    console.warn('  (With a pooler URL, gbrain derives a direct connection for DDL and falls back');
-    console.warn('  to the pooler automatically if that host is unreachable. Power users:');
-    console.warn('  GBRAIN_DIRECT_DATABASE_URL overrides the derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables it.)');
     console.warn('');
   }
 
@@ -1094,9 +1091,6 @@ async function initPostgres(opts: {
       if (databaseUrl.includes('supabase.co') && (msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT'))) {
         console.error('Connection failed. Supabase direct connections (db.*.supabase.co:5432) are IPv6 only.');
         console.error('Use the Transaction pooler connection string instead (port 6543).');
-        console.error('(gbrain derives its own direct connection from pooler URLs for DDL; if that host is');
-        console.error('unreachable it falls back to the pooler. GBRAIN_DIRECT_DATABASE_URL overrides the');
-        console.error('derived URL; GBRAIN_DISABLE_DIRECT_POOL=1 disables the direct pool entirely.)');
       }
       throw e;
     }

src/core/connection-manager.ts

@@ -167,25 +167,6 @@ export function deriveDirectUrl(url: string): string | null {
   }
 }
 
-/**
- * Error codes that mean "the direct host is unreachable from this network"
- * (#1641). The auto-derived db.<ref>.supabase.co host is IPv6-only without
- * the paid IPv4 add-on, so ENOTFOUND/ECONNREFUSED here is expected on
- * IPv4-only networks — we fall back to the pooler instead of failing init.
- */
-const NETWORK_UNREACHABLE_CODES = [
-  'ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH',
-  'ETIMEDOUT', 'CONNECT_TIMEOUT',
-];
-
-/** True when err looks like a network-unreachable failure (not auth/SQL). */
-export function isNetworkUnreachableError(err: unknown): boolean {
-  const code = (err as { code?: unknown } | null)?.code;
-  if (typeof code === 'string' && NETWORK_UNREACHABLE_CODES.includes(code)) return true;
-  const msg = err instanceof Error ? err.message : String(err);
-  return NETWORK_UNREACHABLE_CODES.some(c => msg.includes(c));
-}
-
 /**
  * Read kill-switch state from env. Subordinate to parent manager's state
  * when present (A2 inheritance).
@@ -338,30 +319,7 @@ export class ConnectionManager {
         throw err;
       });
     }
-    let pool: Sql | null;
-    try {
-      pool = await this._directInit;
-    } catch (err) {
-      // #1641: the derived direct host (db.<ref>.supabase.co) is IPv6-only
-      // without Supabase's IPv4 add-on. On IPv4-only networks the direct
-      // pool can never connect — permanently fall back to the read pool
-      // (self-activating kill-switch) instead of failing init/migrations.
-      // Non-network errors (auth, SQL) still throw: they mean misconfig,
-      // not unreachability.
-      if (isNetworkUnreachableError(err)) {
-        const alreadyWarned = this._killSwitch;
-        this._killSwitch = true;
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!alreadyWarned) console.error(
-          `gbrain: direct connection to ${this._directUrl ? this.hostOnly(this._directUrl) : 'unknown host'} unreachable (${msg}); ` +
-          'falling back to the pooler for DDL/bulk (long migrations may hit the pooler statement timeout). ' +
-          'Set GBRAIN_DIRECT_DATABASE_URL to a reachable direct URL (e.g. the Session pooler, port 5432) or enable the Supabase IPv4 add-on; ' +
-          'GBRAIN_DISABLE_DIRECT_POOL=1 silences this.',
-        );
-        return this.getReadPool();
-      }
-      throw err;
-    }
+    const pool = await this._directInit;
     if (!pool) {
       // Defensive — initDirectPool should have thrown.
       throw new Error('connection-manager: direct pool init returned null');
@@ -392,9 +350,8 @@ export class ConnectionManager {
       },
     };
     const t0 = Date.now();
-    let pool: Sql | null = null;
     try {
-      pool = postgres(this._directUrl, opts);
+      const pool = postgres(this._directUrl, opts);
       // Probe to validate connectivity early.
       await pool`SELECT 1`;
       logConnectionEvent({
@@ -405,9 +362,6 @@ export class ConnectionManager {
       });
       return pool;
     } catch (err) {
-      // Don't leak the failed pool's sockets/timers (#1641 fallback keeps
-      // the process running afterward).
-      if (pool) await endPoolBounded(pool);
       logConnectionEvent({
         pool: 'ddl',
         op: 'error',

src/core/cycle.ts

@@ -855,8 +855,16 @@ 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).
+ *
+ * Exported for dream.ts (#1869): a `gbrain dream --dir <path>` run whose
+ * path matches a registered source's local_path is a per-source cycle in
+ * everything but name, so dream derives the source id up front and passes
+ * it as opts.sourceId — landing the freshness stamp without changing
+ * runCycle's stamp/lock semantics for legacy global callers (the
+ * autopilot-global-maintenance handler runs GLOBAL_PHASES with a brainDir
+ * and MUST NOT stamp per-source freshness; see rejected PR #2549).
  */
-async function resolveSourceForDir(
+export async function resolveSourceForDir(
   engine: BrainEngine,
   brainDir: string | null,
 ): Promise<string | undefined> {

test/autopilot-shutdown-engine-close.test.ts

@@ -0,0 +1,63 @@
+/**
+ * #1872 — autopilot SIGTERM/SIGINT must close the engine before exit.
+ *
+ * On PGLite the cycle steps run INLINE in the autopilot process, so a hard
+ * `process.exit` mid-write (systemctl stop → SIGTERM) kills WASM Postgres
+ * with the WAL dirty and can corrupt the brain. Two exit paths must both
+ * close the engine:
+ *
+ *   - autopilot's own shutdown() (owns SIGINT + internal stops like
+ *     max_crashes / cycle-failure-cap), and
+ *   - process-cleanup's SIGTERM handler (installed at cli.ts module load,
+ *     which exits within its 3s cleanup deadline) — reached via the
+ *     registered 'autopilot-engine-close' cleanup callback.
+ *
+ * Because the shutdown path is deep inside `runAutopilot()` (a long-running
+ * daemon loop that ends in process.exit), a behavioral test would have to
+ * spawn + signal a real daemon. Following the established precedent
+ * (test/autopilot-supervisor-wiring.test.ts, test/autopilot-fanout-wiring.test.ts),
+ * these static-shape regressions pin the load-bearing wiring instead.
+ */
+import { describe, expect, it } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const AUTOPILOT_SRC = readFileSync(
+  join(import.meta.dir, '..', 'src', 'commands', 'autopilot.ts'),
+  'utf8',
+);
+
+describe('autopilot.ts graceful engine shutdown (#1872)', () => {
+  it('registers an engine-close callback in the process-cleanup registry (SIGTERM path)', () => {
+    // process-cleanup owns SIGTERM (installed at cli.ts:10) and hard-exits
+    // after its cleanup pass; without this registration the engine is never
+    // closed on `systemctl stop`.
+    expect(AUTOPILOT_SRC).toContain(
+      "import { registerCleanup } from '../core/process-cleanup.ts';",
+    );
+    expect(AUTOPILOT_SRC).toContain(
+      "registerCleanup('autopilot-engine-close', closeEngine)",
+    );
+  });
+
+  it('closeEngine aborts the in-flight inline cycle then disconnects the engine', () => {
+    // Abort first (runCycle checks the signal between phases and threads it
+    // into phase sub-work), bounded drain, then disconnect.
+    expect(AUTOPILOT_SRC).toMatch(
+      /const closeEngine = async \(\) => \{[\s\S]{0,900}shutdownAbort\.abort\([\s\S]{0,900}engine\.disconnect\(\)/,
+    );
+  });
+
+  it('the inline runCycle call carries the shutdown abort signal and is tracked as in-flight', () => {
+    // PGLite / --inline path: the cycle runs in-process, so shutdown must be
+    // able to (a) signal it to wind down and (b) await it before closing.
+    expect(AUTOPILOT_SRC).toMatch(/signal:\s*shutdownAbort\.signal/);
+    expect(AUTOPILOT_SRC).toMatch(/inflightInlineCycle\s*=\s*cyclePromise/);
+  });
+
+  it('shutdown() awaits closeEngine() before process.exit(0) (SIGINT + internal-stop path)', () => {
+    expect(AUTOPILOT_SRC).toMatch(
+      /await closeEngine\(\);[\s\S]{0,400}process\.exit\(0\)/,
+    );
+  });
+});

test/connection-manager.serial.test.ts

@@ -3,7 +3,6 @@ import {
   isSupabasePoolerUrl,
   deriveDirectUrl,
   readKillSwitchEnv,
-  isNetworkUnreachableError,
   resolveDirectPoolSize,
   ConnectionManager,
   DEFAULT_DIRECT_POOL_SIZE,
@@ -239,65 +238,3 @@ describe('ConnectionManager — parent inheritance (A2)', () => {
     }
   });
 });
-
-describe('isNetworkUnreachableError (#1641)', () => {
-  test('classifies network codes as unreachable', () => {
-    for (const code of ['ENOTFOUND', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'ETIMEDOUT', 'CONNECT_TIMEOUT']) {
-      const err = Object.assign(new Error('connect failed'), { code });
-      expect(isNetworkUnreachableError(err)).toBe(true);
-    }
-  });
-
-  test('classifies by message when code absent', () => {
-    expect(isNetworkUnreachableError(new Error('getaddrinfo ENOTFOUND db.abc.supabase.co'))).toBe(true);
-  });
-
-  test('auth/SQL errors are NOT unreachable', () => {
-    expect(isNetworkUnreachableError(new Error('password authentication failed for user "postgres"'))).toBe(false);
-    expect(isNetworkUnreachableError(new Error('syntax error at or near "SELEC"'))).toBe(false);
-    expect(isNetworkUnreachableError(null)).toBe(false);
-  });
-});
-
-describe('ConnectionManager — direct-pool fallback on unreachable host (#1641)', () => {
-  let originalKillSwitch: string | undefined;
-  let originalError: typeof console.error;
-  let errLines: string[];
-  beforeEach(() => {
-    originalKillSwitch = process.env.GBRAIN_DISABLE_DIRECT_POOL;
-    delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
-    originalError = console.error;
-    errLines = [];
-    console.error = (...args: unknown[]) => { errLines.push(args.join(' ')); };
-  });
-  afterEach(() => {
-    console.error = originalError;
-    if (originalKillSwitch === undefined) delete process.env.GBRAIN_DISABLE_DIRECT_POOL;
-    else process.env.GBRAIN_DISABLE_DIRECT_POOL = originalKillSwitch;
-  });
-
-  test('ddl() falls back to the read pool when the direct host is unreachable', async () => {
-    const cm = new ConnectionManager({
-      url: 'postgresql://postgres.abc:p@aws.pooler.supabase.com:6543/db',
-      // 127.0.0.1:9 (discard) → instant ECONNREFUSED, the IPv4-only-network shape.
-      directUrl: 'postgresql://postgres:p@127.0.0.1:9/db',
-    });
-    const fakeReadPool = {} as ReturnType<typeof ConnectionManager.prototype.read>;
-    cm.setReadPool(fakeReadPool);
-    expect(cm.isDualPoolActive()).toBe(true);
-
-    const pool = await cm.ddl(); // without the fix this throws ECONNREFUSED
-    expect(pool).toBe(fakeReadPool);
-    // Self-activating kill-switch: subsequent calls skip the direct pool.
-    expect(cm.isKillSwitchActive()).toBe(true);
-    expect(cm.isDualPoolActive()).toBe(false);
-    expect(cm.describeMode().mode).toBe('single (kill-switch)');
-    // One stderr line mentioning the power-user override.
-    const warning = errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL'));
-    expect(warning.length).toBe(1);
-
-    const again = await cm.ddl();
-    expect(again).toBe(fakeReadPool);
-    expect(errLines.filter(l => l.includes('GBRAIN_DIRECT_DATABASE_URL')).length).toBe(1);
-  }, 20000);
-});

test/dream-dir-source-stamp.test.ts

@@ -0,0 +1,99 @@
+/**
+ * #1869 — `gbrain dream --dir <path>` stamps cycle freshness when the path
+ * matches a registered source's local_path.
+ *
+ * Pre-fix, only `--source <id>` runs wrote last_source_cycle_at /
+ * last_full_cycle_at (runCycle's stamp gate reads opts.sourceId, and dream
+ * never derived one from --dir), so a path-scoped brain showed doctor's
+ * cycle_freshness as perpetually stale.
+ *
+ * The fix lives in dream.ts (derive the source id from the resolved brain
+ * dir via resolveSourceForDir), NOT in runCycle's stamp gate — a runCycle-
+ * wide change would make the autopilot-global-maintenance handler (global
+ * phases, brainDir set, no sourceId) falsely stamp per-source freshness
+ * (the #2194 poisoning class; see rejected PR #2549).
+ *
+ * Same real-PGLite/no-mocks discipline as test/dream.test.ts; same
+ * GBRAIN_HOME isolation as test/cycle-last-full-cycle-at.test.ts (the
+ * cycle's PGLite file lock lives under ~/.gbrain).
+ */
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { PGLiteEngine } from '../src/core/pglite-engine.ts';
+import { resetPgliteState } from './helpers/reset-pglite.ts';
+import { runDream } from '../src/commands/dream.ts';
+import { withEnv } from './helpers/with-env.ts';
+
+let engine: PGLiteEngine;
+let brainDir: string;
+let gbrainHome: string;
+
+beforeAll(async () => {
+  engine = new PGLiteEngine();
+  await engine.connect({});
+  await engine.initSchema();
+}, 60_000);
+
+afterAll(async () => {
+  await engine.disconnect();
+});
+
+beforeEach(async () => {
+  await resetPgliteState(engine);
+  brainDir = mkdtempSync(join(tmpdir(), 'gbrain-dream-stamp-'));
+  gbrainHome = mkdtempSync(join(tmpdir(), 'gbrain-dream-stamp-home-'));
+}, 60_000);
+
+afterEach(() => {
+  rmSync(brainDir, { recursive: true, force: true });
+  rmSync(gbrainHome, { recursive: true, force: true });
+});
+
+async function seedSource(id: string, archived = false): Promise<void> {
+  await engine.executeRaw(
+    `INSERT INTO sources (id, name, local_path, config, archived, created_at)
+     VALUES ($1, $2, $3, '{}'::jsonb, $4, NOW())`,
+    [id, id, brainDir, archived],
+  );
+}
+
+async function readLastFullCycleAt(sourceId: string): Promise<string | null> {
+  const rows = await engine.executeRaw<{ config: Record<string, unknown> | null }>(
+    `SELECT config FROM sources WHERE id = $1`,
+    [sourceId],
+  );
+  const raw = rows[0]?.config?.last_full_cycle_at;
+  return typeof raw === 'string' ? raw : null;
+}
+
+describe('gbrain dream --dir <path> freshness stamp (#1869)', () => {
+  test('--dir matching a source local_path stamps last_full_cycle_at', async () => {
+    await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
+      await seedSource('path-scoped');
+      expect(await readLastFullCycleAt('path-scoped')).toBeNull();
+
+      const report = await runDream(engine, ['--dir', brainDir, '--phase', 'lint', '--json']);
+      expect(report).toBeTruthy();
+      if (report) expect(['ok', 'clean']).toContain(report.status);
+
+      // Pre-fix this stays null forever: dream never passed a sourceId, so
+      // runCycle's stamp gate skipped the write.
+      expect(await readLastFullCycleAt('path-scoped')).not.toBeNull();
+    });
+  }, 60_000);
+
+  test('--dir matching an ARCHIVED source does not stamp it', async () => {
+    await withEnv({ GBRAIN_HOME: gbrainHome }, async () => {
+      await seedSource('mothballed', true);
+
+      const report = await runDream(engine, ['--dir', brainDir, '--phase', 'lint', '--json']);
+      expect(report).toBeTruthy();
+
+      // Stamping an archived source would mask data staleness when it is
+      // later restored (mirrors the explicit --source archived guard).
+      expect(await readLastFullCycleAt('mothballed')).toBeNull();
+    });
+  }, 60_000);
+});

test/dream.test.ts

@@ -562,12 +562,22 @@ describe('runDream — --source / --source-id (v0.41.13)', () => {
 
   // ─── Back-compat: bare `gbrain dream` does NOT write per-source stamp ─
 
-  test('gbrain dream (no --source) leaves all sources untouched (back-compat regression)', async () => {
-    await seedSource('alpha');
-    await seedSource('beta');
+  test('gbrain dream (no --source) stamps only the source whose local_path matches --dir (#1869)', async () => {
+    // Pre-#1869 this asserted NO source was ever stamped without an explicit
+    // --source — which is exactly the bug: a path-scoped `gbrain dream --dir`
+    // run never landed a freshness stamp and doctor's cycle_freshness stayed
+    // stale forever. New truth: the source whose local_path matches the
+    // resolved brain dir is derived and stamped; unrelated sources stay
+    // untouched (cross-source isolation).
+    await seedSource('alpha'); // local_path = repo → derived + stamped
+    await engine.executeRaw(
+      `INSERT INTO sources (id, name, local_path, config, archived, created_at)
+       VALUES ($1, $2, $3, '{}'::jsonb, false, NOW())`,
+      ['beta', 'beta', '/somewhere/else'],
+    );
     const report = await runDream(engine, ['--dir', repo, '--phase', 'lint', '--json']);
     expect(report).toBeTruthy();
-    expect(await readLastFullCycleAt('alpha')).toBeNull();
+    expect(await readLastFullCycleAt('alpha')).not.toBeNull();
     expect(await readLastFullCycleAt('beta')).toBeNull();
   }, 60_000);