fix(dream): deterministic last-writer attribution for colliding slugs

collectChildPutPageSlugs paired each slug to a jobId first-seen over an unordered result set. When two children collide on a final slug, the pages row holds the LAST put_page write, so the provenance stamp (transcript_id/transcript_source/date) could attribute an arbitrary other transcript. ORDER BY id + last-writer-wins aligns the stamp with the surviving content; pinned by a collision test. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
test(progress): assert net-zero live-reporter delta, not absolute zero
2026-08-16 09:52:22 +00:00 · 2026-07-22 12:14:19 -07:00 · 2026-07-22 11:22:03 -07:00 · 2026-07-21 14:25:51 -07:00
19 changed files with 432 additions and 354 deletions
@@ -7,7 +7,7 @@
  <link rel="preconnect" href="https://fonts.googleapis.com" />
  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/admin/assets/index-CzLjRij_.js"></script>
+  <script type="module" crossorigin src="/admin/assets/index-CoGEje3-.js"></script>
  <link rel="stylesheet" crossorigin href="/admin/assets/index-GxkWX7v3.css">
 </head>
 <body>
@@ -39,7 +39,6 @@ export const api = {
  stats: () => apiFetch('/admin/api/stats'),
  health: () => apiFetch('/admin/api/health-indicators'),
  agents: () => apiFetch('/admin/api/agents'),
-  sources: () => apiFetch('/admin/api/sources'),
  requests: (page = 1, qs = '') => apiFetch(`/admin/api/requests?page=${page}${qs}`),
  apiKeys: () => apiFetch('/admin/api/api-keys'),
  createApiKey: (name: string) => apiFetch('/admin/api/api-keys', { method: 'POST', body: JSON.stringify({ name }) }),
@@ -23,16 +23,9 @@ interface Agent {
  total_requests: number;
  requests_today: number;
  token_ttl: number | null;
-  source_id: string | null;
-  federated_read: string[] | null;
  status: 'active' | 'revoked';
 }

-interface SourceOption {
-  id: string;
-  name: string | null;
-}
-
 interface ApiKey {
  id: string;
  name: string;
@@ -95,7 +88,6 @@ export function AgentsPage() {
                <th>Name</th>
                <th>Type</th>
                <th>Scopes</th>
-                <th>Source</th>
                <th>Status</th>
                <th>Requests</th>
                <th>Last Used</th>
@@ -116,9 +108,6 @@ export function AgentsPage() {
                      <span key={s} className={`badge badge-${s}`} style={{ marginRight: 4 }}>{s}</span>
                    ))}
                  </td>
-                  <td className="mono" style={{ fontSize: 12, color: 'var(--text-secondary)' }}>
-                    {a.auth_type === 'oauth' ? (a.source_id || 'default') : 'all'}
-                  </td>
                  <td>
                    <span className={`badge ${a.status === 'active' ? 'badge-success' : 'badge-danger'}`}>{a.status}</span>
                  </td>
@@ -268,29 +257,9 @@ function RegisterModal({ onClose, onRegistered }: {
    Object.fromEntries(ALLOWED_SCOPES_LIST.map(s => [s, s === 'read'])) as Record<Scope, boolean>,
  );
  const [ttl, setTtl] = useState('86400'); // 24h default
-  const [redirectUris, setRedirectUris] = useState('');
-  const [sources, setSources] = useState<SourceOption[]>([{ id: 'default', name: 'default' }]);
-  const [sourceId, setSourceId] = useState('default');
-  const [readSources, setReadSources] = useState<Record<string, boolean>>({ default: true });
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

-  useEffect(() => {
-    api.sources()
-      .then((rows: SourceOption[]) => {
-        const nextSources = rows.length > 0 ? rows : [{ id: 'default', name: 'default' }];
-        const nextSourceId = nextSources.some(s => s.id === sourceId) ? sourceId : nextSources[0].id;
-        setSources(nextSources);
-        setSourceId(nextSourceId);
-        setReadSources(prev => {
-          const next = Object.fromEntries(nextSources.map(s => [s.id, Boolean(prev[s.id])])) as Record<string, boolean>;
-          next[nextSourceId] = true;
-          return next;
-        });
-      })
-      .catch(() => {});
-  }, []);
-
  const ttlOptions = [
    { label: '1 hour', value: '3600' },
    { label: '24 hours', value: '86400' },
@@ -308,24 +277,11 @@ function RegisterModal({ onClose, onRegistered }: {
    try {
      // Use the CLI registration endpoint (POST to admin API)
      const selectedScopes = Object.entries(scopes).filter(([, v]) => v).map(([k]) => k).join(' ');
-      const federatedRead = sources.map(s => s.id).filter(id => readSources[id]);
-      if (federatedRead.length === 0) { setError('Select at least one read source'); setLoading(false); return; }
-      // #1036: redirect URIs, one per line. Mirrors the CLI convention
-      // (src/commands/auth.ts): presence of redirect URIs implies
-      // authorization_code + refresh_token grants unless the user had none.
-      const uris = redirectUris.split('\n').map(u => u.trim()).filter(Boolean);
      const res = await fetch('/admin/api/register-client', {
        method: 'POST',
        credentials: 'same-origin',
        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          name: name.trim(),
-          scopes: selectedScopes,
-          tokenTtl: ttl === '0' ? 315360000 : Number(ttl),
-          source_id: sourceId,
-          federated_read: federatedRead,
-          ...(uris.length > 0 ? { redirectUris: uris, grantTypes: ['authorization_code', 'refresh_token'] } : {}),
-        }),
+        body: JSON.stringify({ name: name.trim(), scopes: selectedScopes, tokenTtl: ttl === '0' ? 315360000 : Number(ttl) }),
      });
      if (!res.ok) throw new Error('Registration failed');
      const data = await res.json();
@@ -356,42 +312,6 @@ function RegisterModal({ onClose, onRegistered }: {
            ))}
          </div>
        </div>
-        <div style={{ marginBottom: 16 }}>
-          <label>Write Source</label>
-          <select value={sourceId} onChange={e => {
-            const id = e.target.value;
-            setSourceId(id);
-            setReadSources(p => ({ ...p, [id]: true }));
-          }}
-            style={{ width: '100%', background: 'var(--bg-secondary)', color: 'var(--text-primary)', border: '1px solid var(--border)', borderRadius: 6, padding: '6px 10px', fontSize: 14 }}>
-            {sources.map(s => <option key={s.id} value={s.id}>{s.name && s.name !== s.id ? `${s.id} (${s.name})` : s.id}</option>)}
-          </select>
-        </div>
-        <div style={{ marginBottom: 16 }}>
-          <label>Read Sources</label>
-          <div className="checkbox-group">
-            {sources.map(s => (
-              <label key={s.id} className="checkbox-label">
-                <input
-                  type="checkbox"
-                  checked={Boolean(readSources[s.id])}
-                  onChange={e => setReadSources(p => ({ ...p, [s.id]: e.target.checked }))}
-                />
-                {s.name && s.name !== s.id ? `${s.id} (${s.name})` : s.id}
-              </label>
-            ))}
-          </div>
-        </div>
-        <div style={{ marginBottom: 16 }}>
-          <label>Redirect URIs <span style={{ color: 'var(--text-secondary)', fontWeight: 400 }}>(optional, one per line — enables authorization_code flow)</span></label>
-          <textarea
-            placeholder={'https://example.com/callback'}
-            value={redirectUris}
-            onChange={e => setRedirectUris(e.target.value)}
-            rows={2}
-            style={{ width: '100%', background: 'var(--bg-secondary)', color: 'var(--text-primary)', border: '1px solid var(--border)', borderRadius: 6, padding: '6px 10px', fontSize: 13, fontFamily: 'inherit', resize: 'vertical' }}
-          />
-        </div>
        <div style={{ marginBottom: 20 }}>
          <label>Token Lifetime</label>
          <select value={ttl} onChange={e => setTtl(e.target.value)}
@@ -608,8 +528,6 @@ function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: ()
      client_name: agentName,
      auth_type: agent.auth_type,
      scope: agent.scope,
-      source_id: agent.source_id,
-      federated_read: agent.federated_read,
    }, null, 2),
  };

@@ -629,10 +547,6 @@ function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: ()
          <span>{(agent.scope || '').split(' ').filter(Boolean).map(s => (
            <span key={s} className={`badge badge-${s}`} style={{ marginRight: 4 }}>{s}</span>
          ))}</span>
-          <span style={{ color: 'var(--text-secondary)' }}>Write Source</span>
-          <span className="mono">{agent.source_id || (isOAuth ? 'default' : 'all')}</span>
-          <span style={{ color: 'var(--text-secondary)' }}>Read Sources</span>
-          <span className="mono">{isOAuth ? (agent.federated_read && agent.federated_read.length > 0 ? agent.federated_read.join(', ') : (agent.source_id || 'default')) : 'all'}</span>
          <span style={{ color: 'var(--text-secondary)' }}>Registered</span>
          <span>{new Date(agent.created_at).toLocaleDateString()}</span>
          <span style={{ color: 'var(--text-secondary)' }}>Token TTL</span>
@@ -1,13 +1,13 @@
 // AUTO-GENERATED — do not edit by hand.
 // Run `bun run scripts/build-admin-embedded.ts` to regenerate.
-// Source: admin/dist/ at 2026-07-21.
+// Source: admin/dist/ at 2026-05-27.
 //
 // Bun resolves the file: imports to a path that works at runtime even
 // inside a compiled binary (`bun build --compile`). The manifest maps
 // the request path the express handler sees to (resolved-path, mime).

 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
-import A_0_assets_index_CzLjRij__js from '../admin/dist/assets/index-CzLjRij_.js' with { type: 'file' };
+import A_0_assets_index_CoGEje3__js from '../admin/dist/assets/index-CoGEje3-.js' with { type: 'file' };
 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
 import A_1_assets_index_GxkWX7v3_css from '../admin/dist/assets/index-GxkWX7v3.css' with { type: 'file' };
 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
@@ -19,7 +19,7 @@ export interface AdminAsset {
 }

 export const ADMIN_ASSETS: Record<string, AdminAsset> = {
-  "/admin/assets/index-CzLjRij_.js": { path: A_0_assets_index_CzLjRij__js as unknown as string, mime: "application/javascript; charset=utf-8" },
+  "/admin/assets/index-CoGEje3-.js": { path: A_0_assets_index_CoGEje3__js as unknown as string, mime: "application/javascript; charset=utf-8" },
  "/admin/assets/index-GxkWX7v3.css": { path: A_1_assets_index_GxkWX7v3_css as unknown as string, mime: "text/css; charset=utf-8" },
  "/admin/index.html": { path: A_2_index_html as unknown as string, mime: "text/html; charset=utf-8" },
 };
@@ -39,7 +39,6 @@ import * as db from '../core/db.ts';
 import { sqlQueryForEngine, executeRawJsonb } from '../core/sql-query.ts';
 import { MinionQueue } from '../core/minions/queue.ts';
 import { isRetryableError } from '../core/retry-matcher.ts';
-import { normalizeAdminClientSourceScope } from '../core/admin-source-scope.ts';
 import {
  computeContentHash,
  validateIngestionEvent,
@@ -1087,7 +1086,6 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
      const oauthClients = await sql`
        SELECT c.client_id as id, c.client_name as name, 'oauth' as auth_type,
          c.grant_types, c.scope, c.created_at, c.token_ttl,
-          c.source_id, c.federated_read,
          CASE WHEN c.deleted_at IS NOT NULL THEN 'revoked' ELSE 'active' END as status,
          (SELECT max(created_at) FROM mcp_request_log WHERE token_name = c.client_id) as last_used_at,
          (SELECT count(*)::int FROM mcp_request_log WHERE token_name = c.client_id) as total_requests,
@@ -1097,7 +1095,6 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
      const legacyKeys = await sql`
        SELECT a.id, a.name, 'api_key' as auth_type,
          '{"bearer"}' as grant_types, 'read write admin' as scope, a.created_at, null as token_ttl,
-          null as source_id, null as federated_read,
          CASE WHEN a.revoked_at IS NOT NULL THEN 'revoked' ELSE 'active' END as status,
          a.last_used_at,
          (SELECT count(*)::int FROM mcp_request_log WHERE token_name = a.name) as total_requests,
@@ -1110,17 +1107,6 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
    }
  });

-  app.get('/admin/api/sources', requireAdmin, async (_req: Request, res: Response) => {
-    try {
-      const sources = await engine.listAllSources({ includeArchived: false });
-      const options = sources.map(s => ({ id: s.id, name: s.name }));
-      if (!options.some(s => s.id === 'default')) options.unshift({ id: 'default', name: 'default' });
-      res.json(options);
-    } catch (e) {
-      res.status(503).json({ error: 'service_unavailable' });
-    }
-  });
-
  // v0.38 Slice 4 — per-OAuth-client agent spend viewer. Pre-computes today's
  // spend (committed + pending reservations) per client so the Agents tab
  // can render a "$X / $Y today" cell. Read-side endpoint only — no mutation.
@@ -1454,8 +1440,6 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
      // missing, empty) and rejects the rest with a structured 400.
      const { name, tokenTtl, grantTypes, redirectUris, tokenEndpointAuthMethod } = req.body;
      const rawScopes = (req.body as Record<string, unknown>).scopes ?? (req.body as Record<string, unknown>).scope;
-      const rawSourceId = (req.body as Record<string, unknown>).source_id ?? (req.body as Record<string, unknown>).sourceId;
-      const rawFederatedRead = (req.body as Record<string, unknown>).federated_read ?? (req.body as Record<string, unknown>).federatedRead;
      if (!name) { res.status(400).json({ error: 'Name required' }); return; }
      let scopeString: string;
      try {
@@ -1486,23 +1470,8 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
        });
        return;
      }
-      let sourceScope: ReturnType<typeof normalizeAdminClientSourceScope>;
-      try {
-        const sources = await engine.listAllSources({ includeArchived: false });
-        sourceScope = normalizeAdminClientSourceScope(
-          rawSourceId,
-          rawFederatedRead,
-          sources.map(s => s.id),
-        );
-      } catch (e) {
-        res.status(400).json({
-          error: 'invalid_source_scope',
-          message: e instanceof Error ? e.message : String(e),
-        });
-        return;
-      }
      const result = await oauthProvider.registerClientManual(
-        name, grants, scopeString, uris, sourceScope.sourceId, sourceScope.federatedRead, validatedAuthMethod,
+        name, grants, scopeString, uris, 'default', undefined, validatedAuthMethod,
      );
      // Set per-client TTL if specified
      if (tokenTtl && Number(tokenTtl) > 0) {
@@ -1,51 +0,0 @@
-import { isValidSourceId } from './source-id.ts';
-
-export interface AdminClientSourceScope {
-  sourceId: string;
-  federatedRead: string[];
-}
-
-function parseFederatedReadInput(raw: unknown, sourceId: string): string[] {
-  if (raw === undefined || raw === null) return [sourceId];
-  if (typeof raw === 'string') {
-    const values = raw.split(',').map(s => s.trim()).filter(Boolean);
-    return values.length > 0 ? values : [sourceId];
-  }
-  if (Array.isArray(raw)) {
-    if (!raw.every(v => typeof v === 'string')) {
-      throw new Error('federated_read must be an array of source ids');
-    }
-    const values = raw.map(v => v.trim()).filter(Boolean);
-    return values.length > 0 ? values : [sourceId];
-  }
-  throw new Error('federated_read must be a string or array');
-}
-
-export function normalizeAdminClientSourceScope(
-  rawSourceId: unknown,
-  rawFederatedRead: unknown,
-  availableSourceIds: string[],
-): AdminClientSourceScope {
-  const knownSources = new Set(availableSourceIds);
-  const fallbackSourceId = knownSources.has('default') ? 'default' : (availableSourceIds[0] ?? 'default');
-  const sourceId = rawSourceId === undefined || rawSourceId === null || rawSourceId === ''
-    ? fallbackSourceId
-    : rawSourceId;
-  if (!isValidSourceId(sourceId)) {
-    throw new Error(`Invalid source_id: ${JSON.stringify(sourceId)}`);
-  }
-  if (knownSources.size > 0 && !knownSources.has(sourceId)) {
-    throw new Error(`Unknown source_id: ${sourceId}`);
-  }
-
-  const federatedRead = Array.from(new Set(parseFederatedReadInput(rawFederatedRead, sourceId)));
-  for (const id of federatedRead) {
-    if (!isValidSourceId(id)) {
-      throw new Error(`Invalid federated_read source_id: ${JSON.stringify(id)}`);
-    }
-    if (knownSources.size > 0 && !knownSources.has(id)) {
-      throw new Error(`Unknown federated_read source_id: ${id}`);
-    }
-  }
-  return { sourceId, federatedRead };
-}
@@ -428,8 +428,13 @@ export async function runPhaseSynthesize(

    const queue = new MinionQueue(engine);
    const childIds: number[] = [];
-    /** Map child job_id → chunk metadata for D6 orchestrator-side slug rewrite. */
-    const chunkInfo = new Map<number, { idx: number; hash6: string }>();
+    /**
+     * Map child job_id → transcript metadata. Drives D6 orchestrator-side
+     * slug rewrite for chunked transcripts AND the deterministic frontmatter
+     * stampDreamProvenance merges into each written page. Populated for
+     * every child (single-chunk children carry chunkTotal=1).
+     */
+    const childMeta = new Map<number, ChildMeta>();
    /** Skip reasons for the cycle report (D5 cap hits, D8 legacy-key skips). */
    const skipReports: Array<{ filePath: string; reason: string }> = [];

@@ -513,9 +518,14 @@ export async function runPhaseSynthesize(
          { allowProtectedSubmit: true },
        );
        childIds.push(child.id);
-        if (isChunked) {
-          chunkInfo.set(child.id, { idx: i, hash6 });
-        }
+        childMeta.set(child.id, {
+          idx: i,
+          hash6,
+          chunkTotal: chunks.length,
+          transcriptSource: t.transcriptSource,
+          transcriptId: stripContentVersionSuffix(t.basename),
+          inferredDate: t.inferredDate,
+        });
      }
    }

@@ -544,14 +554,14 @@ export async function runPhaseSynthesize(

    // Collect slugs from put_page tool executions across the children
    // (codex finding #2: deterministic provenance, NOT pages.updated_at).
-    // D6 orchestrator slug rewrite: chunkInfo drives post-hoc rewrite of
+    // D6 orchestrator slug rewrite: childMeta drives post-hoc rewrite of
    // bare-hash slugs to `<hash6>-c<idx>` so chunked siblings can't collide
    // even if Sonnet drops the chunk suffix.
    // v0.32.8: refs carry source_id so reverseWriteRefs picks the correct
    // (source, slug) row. #1586: refs are stamped with the cycle's resolved
    // source (children write there via SubagentHandlerData.source_id).
    const cycleSourceId = opts.sourceId ?? 'default';
-    const writtenRefs = await collectChildPutPageSlugs(engine, childIds, chunkInfo, cycleSourceId);
+    const writtenRefs = await collectChildPutPageSlugs(engine, childIds, childMeta, cycleSourceId);

    const summaryDate = opts.date ?? today();

@@ -559,7 +569,12 @@ export async function runPhaseSynthesize(
    // of every child-written page BEFORE reverse-rendering, so generated pages
    // are queryable (`frontmatter->>'dream_generated'`) and a later put_page
    // write-through (which re-renders from the DB row) can't erase the stamp.
-    await stampDreamProvenance(engine, writtenRefs, summaryDate);
+    // #2285: the stamp also carries the orchestrator-owned deterministic
+    // frontmatter (transcript_id, transcript_source, transcript_hash, date,
+    // chunk) derived from childMeta — subagent drift on those fields can't
+    // leak, and reverseWriteRefs below re-reads the row so the same fields
+    // land in the on-disk markdown.
+    await stampDreamProvenance(engine, writtenRefs, summaryDate, childMeta);

    // Dual-write: reverse-render each DB row → markdown file.
    const reverseWriteCount = await reverseWriteRefs(engine, opts.brainDir, writtenRefs, cycleSourceId);
@@ -1095,15 +1110,17 @@ function sanitizeForSlug(s: string): string {
 * fake"): we no longer need detection because the rewrite enforces
 * uniqueness at slug-write time.
 *
- * `chunkInfo` maps child job_id → { chunk_index, hash6 }. Single-chunk
- * children are absent from the map and pass through unchanged.
+ * `childMeta` maps child job_id → per-child transcript metadata. Chunked
+ * children (chunkTotal > 1) get the slug rewrite; single-chunk children
+ * pass through unchanged. Each returned ref carries the job_id that wrote
+ * it so stampDreamProvenance can pair the slug back to its childMeta entry.
 */
 async function collectChildPutPageSlugs(
  engine: BrainEngine,
  childIds: number[],
-  chunkInfo: Map<number, { idx: number; hash6: string }>,
+  childMeta: Map<number, ChildMeta>,
  sourceId = 'default',
-): Promise<Array<{ slug: string; source_id: string }>> {
+): Promise<Array<{ slug: string; source_id: string; jobId: number }>> {
  if (childIds.length === 0) return [];
  // Raw fetch — NO SELECT DISTINCT. Preserves per-child slug duplicates so
  // the orchestrator sees what each child wrote. COALESCE handles both
@@ -1122,16 +1139,73 @@ async function collectChildPutPageSlugs(
       FROM subagent_tool_executions
      WHERE job_id = ANY($1::int[])
        AND tool_name = 'brain_put_page'
-        AND status = 'complete'`,
+        AND status = 'complete'
+      ORDER BY id`,
    [childIds],
  );
-  const rewritten = new Set<string>();
+  const rewritten = new Map<string, number>();
  for (const r of rows) {
    if (typeof r.slug !== 'string' || r.slug.length === 0) continue;
-    const ci = chunkInfo.get(r.job_id);
-    rewritten.add(ci ? rewriteChunkedSlug(r.slug, ci.hash6, ci.idx) : r.slug);
+    const meta = childMeta.get(r.job_id);
+    const finalSlug = meta && meta.chunkTotal > 1
+      ? rewriteChunkedSlug(r.slug, meta.hash6, meta.idx)
+      : r.slug;
+    // Last writer wins, in execution-row order (ORDER BY id): if two children
+    // collide on a final slug, the pages row holds the LAST put_page write, so
+    // the stamp must attribute that child's transcript — not an arbitrary one.
+    rewritten.set(finalSlug, r.job_id);
  }
-  return Array.from(rewritten).sort().map(slug => ({ slug, source_id: sourceId }));
+  return [...rewritten.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([slug, jobId]) => ({ slug, source_id: sourceId, jobId }));
+}
+
+/**
+ * Per-child orchestrator state. Drives D6 chunked-slug rewrite (idx + hash6)
+ * AND the deterministic frontmatter stampDreamProvenance merges into each
+ * written page. Populated for every child, not just chunked ones.
+ */
+interface ChildMeta {
+  idx: number;
+  hash6: string;
+  chunkTotal: number;
+  transcriptSource: string | null;
+  transcriptId: string;
+  inferredDate: string | null;
+}
+
+/**
+ * Strip the content-version suffix that claude-code-archive appends when a
+ * conversation is edited (`<uuid>--<contentHash>.md`). The session UUID is
+ * the stable transcript identifier; the suffix changes with content. Used to
+ * populate `transcript_id` so edits of the same session collapse to one id.
+ */
+function stripContentVersionSuffix(basename: string): string {
+  return basename.replace(/--[a-f0-9]+$/i, '');
+}
+
+/**
+ * Deterministic frontmatter for one synthesized page (#2285). Every field
+ * here is owned by the orchestrator — the subagent's value for any of these
+ * is overwritten. The subagent retains authority over type / title / tags /
+ * body. `date` feeds the effective-date precedence chain
+ * (src/core/effective-date.ts) so re-imports keep the conversation date even
+ * when sync tools re-stamp file mtimes.
+ */
+function buildDeterministicFrontmatter(
+  meta: ChildMeta,
+  cycleDate: string,
+): Record<string, unknown> {
+  const overrides: Record<string, unknown> = {
+    dream_generated: true,
+    dream_cycle_date: cycleDate,
+    transcript_id: meta.transcriptId,
+    transcript_hash: meta.hash6,
+  };
+  if (meta.transcriptSource) overrides.transcript_source = meta.transcriptSource;
+  if (meta.chunkTotal > 1) overrides.chunk = `${meta.idx + 1}/${meta.chunkTotal}`;
+  if (meta.inferredDate) overrides.date = meta.inferredDate;
+  return overrides;
 }

 /**
@@ -1177,12 +1251,19 @@ async function hasLegacySingleChunkCompletion(
 */
 async function stampDreamProvenance(
  engine: BrainEngine,
-  refs: Array<{ slug: string; source_id: string }>,
+  refs: Array<{ slug: string; source_id: string; jobId?: number }>,
  cycleDate: string,
+  childMeta?: Map<number, ChildMeta>,
 ): Promise<void> {
  if (refs.length === 0) return;
  const { executeRawJsonb } = await import('../sql-query.ts');
-  for (const { slug, source_id } of refs) {
+  for (const { slug, source_id, jobId } of refs) {
+    // #2285: when the ref pairs back to a child, the stamp also carries the
+    // orchestrator-owned deterministic frontmatter for that transcript.
+    const meta = jobId !== undefined ? childMeta?.get(jobId) : undefined;
+    const stamp = meta
+      ? buildDeterministicFrontmatter(meta, cycleDate)
+      : { dream_generated: true, dream_cycle_date: cycleDate };
    try {
      await executeRawJsonb(
        engine,
@@ -1190,7 +1271,7 @@ async function stampDreamProvenance(
            SET frontmatter = COALESCE(frontmatter, '{}'::jsonb) || $3::jsonb
          WHERE slug = $1 AND source_id = $2`,
        [slug, source_id],
-        [{ dream_generated: true, dream_cycle_date: cycleDate }],
+        [stamp],
      );
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
@@ -10,7 +10,7 @@
 */

 import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { pruneDir } from '../sync.ts';

@@ -23,8 +23,22 @@ export interface DiscoveredTranscript {
  content: string;
  /** Filename basename without extension; used as a topic-slug seed. */
  basename: string;
-  /** Inferred date if the basename matches `YYYY-MM-DD...` (or null). */
+  /**
+   * Inferred conversation date (YYYY-MM-DD) or null. Precedence: the
+   * `| First message | <ISO> |` row in the transcript's `## Metadata`
+   * table (stable across mtime-restamping re-syncs) wins; a leading
+   * `YYYY-MM-DD` in the basename is the fallback.
+   */
  inferredDate: string | null;
+  /**
+   * Transcript source archive name, derived from the path's grandparent
+   * directory (the immediate parent of the date directory). For the
+   * canonical layout `<corpus>/<source>/<date>/<id>.md` this yields the
+   * source-name segment — e.g. `claude-code` for the claude-code-archive
+   * output, `meetings` for meeting recordings. Null when the file does
+   * not live under a `<source>/<date>/` pair (ad-hoc inputs).
+   */
+  transcriptSource: string | null;
 }

 export interface DiscoverOpts {
@@ -161,6 +175,36 @@ function matchesAnyExclude(text: string, patterns: RegExp[]): boolean {
  return false;
 }

+/**
+ * Content-based conversation date: the `| First message | <ISO timestamp> |`
+ * row claude-code-archive writes into the transcript's `## Metadata` table.
+ * Stable across rsync/Dropbox/Syncthing/B2 re-syncs that re-stamp mtime,
+ * unlike anything derived from file metadata. Returns YYYY-MM-DD or null.
+ */
+const FIRST_MESSAGE_RE = /^\|\s*First message\s*\|\s*(\d{4}-\d{2}-\d{2})/im;
+
+export function inferContentDate(content: string): string | null {
+  const m = FIRST_MESSAGE_RE.exec(content);
+  return m ? m[1] : null;
+}
+
+/**
+ * Derive the archive source name from a transcript path. Returns the basename
+ * of the directory two levels above the file when the immediate parent is a
+ * date directory and the grandparent looks like a source-name slug (lowercase
+ * alphanumeric segments separated by hyphens); otherwise null. This pins the
+ * canonical claude-code-archive layout `<corpus>/<source>/<date>/<id>.md`
+ * without claiming a source for ad-hoc inputs that don't match.
+ */
+export function deriveTranscriptSource(filePath: string): string | null {
+  const parentName = basename(dirname(filePath));
+  if (!/^\d{4}-\d{2}-\d{2}/.test(parentName)) return null;
+  const grandparentName = basename(dirname(dirname(filePath)));
+  if (!grandparentName) return null;
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(grandparentName)) return null;
+  return grandparentName;
+}
+
 function listTextFiles(dir: string): string[] {
  // Recursive walk with descent-time pruning (closes codex C12/C13 spec gap).
  // Accepts BOTH .txt and .md per transcript-discovery's domain rules — does
@@ -225,8 +269,11 @@ export function discoverTranscripts(opts: DiscoverOpts): DiscoveredTranscript[]
      const ext = filePath.endsWith('.md') ? '.md' : '.txt';
      const baseName = basename(filePath, ext);
      const dateMatch = DATE_RE.exec(baseName);
-      const inferredDate = dateMatch ? dateMatch[1] : null;
-      if (!isInDateRange(inferredDate, opts)) continue;
+      const filenameDate = dateMatch ? dateMatch[1] : null;
+      // Fast path: date-named files outside the window skip before the read.
+      // ponytail: a date-named file whose content date differs is filtered on
+      // its filename date — acceptable; archive layouts use UUID basenames.
+      if (filenameDate && !isInDateRange(filenameDate, opts)) continue;

      let content: string;
      try {
@@ -241,12 +288,17 @@ export function discoverTranscripts(opts: DiscoverOpts): DiscoveredTranscript[]
      }
      if (matchesAnyExclude(content, excludeRes)) continue;

+      // Content-metadata date wins (survives mtime restamps); filename next.
+      const inferredDate = inferContentDate(content) ?? filenameDate;
+      if (!isInDateRange(inferredDate, opts)) continue;
+
      results.push({
        filePath,
        contentHash: hashContent(content),
        content,
        basename: baseName,
        inferredDate,
+        transcriptSource: deriveTranscriptSource(filePath),
      });
    }
  }
@@ -290,6 +342,7 @@ export function readSingleTranscript(
    contentHash: hashContent(content),
    content,
    basename: baseName,
-    inferredDate: dateMatch ? dateMatch[1] : null,
+    inferredDate: inferContentDate(content) ?? (dateMatch ? dateMatch[1] : null),
+    transcriptSource: deriveTranscriptSource(filePath),
  };
 }
@@ -1,44 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { normalizeAdminClientSourceScope } from '../src/core/admin-source-scope.ts';
-
-describe('admin register-client source scope normalization', () => {
-  const sources = ['default', 'team-a', 'team-b'];
-
-  test('defaults write and read scope to default source', () => {
-    expect(normalizeAdminClientSourceScope(undefined, undefined, sources)).toEqual({
-      sourceId: 'default',
-      federatedRead: ['default'],
-    });
-  });
-
-  test('accepts snake-case body fields with multiple read sources', () => {
-    expect(normalizeAdminClientSourceScope('team-a', ['team-a', 'team-b'], sources)).toEqual({
-      sourceId: 'team-a',
-      federatedRead: ['team-a', 'team-b'],
-    });
-  });
-
-  test('accepts comma-separated federated_read for API callers', () => {
-    expect(normalizeAdminClientSourceScope('team-a', 'team-b, default,team-b', sources)).toEqual({
-      sourceId: 'team-a',
-      federatedRead: ['team-b', 'default'],
-    });
-  });
-
-  test('falls back to selected write source when federated_read is empty', () => {
-    expect(normalizeAdminClientSourceScope('team-b', [], sources)).toEqual({
-      sourceId: 'team-b',
-      federatedRead: ['team-b'],
-    });
-  });
-
-  test('rejects malformed source ids before registration', () => {
-    expect(() => normalizeAdminClientSourceScope('../secret', undefined, sources)).toThrow(/Invalid source_id/);
-    expect(() => normalizeAdminClientSourceScope('team-a', ['snake_case'], sources)).toThrow(/Invalid federated_read/);
-  });
-
-  test('rejects valid-looking but unregistered source ids', () => {
-    expect(() => normalizeAdminClientSourceScope('ghost', undefined, sources)).toThrow(/Unknown source_id/);
-    expect(() => normalizeAdminClientSourceScope('team-a', ['ghost'], sources)).toThrow(/Unknown federated_read/);
-  });
-});
@@ -26,6 +26,7 @@ const transcript: DiscoveredTranscript = {
  content: 'User: hello world',
  contentHash: 'abcdef0123456789',
  inferredDate: '2026-07-17',
+  transcriptSource: null,
 } as DiscoveredTranscript;

 describe('#2415: buildSynthesisPrompt output root', () => {
@@ -152,3 +152,94 @@ describe('#2569: stampDreamProvenance persists the marker into DB frontmatter',
    await stampDreamProvenance(engine as any, refs, '2026-07-17'); // idempotent
  });
 });
+
+describe('#2285: orchestrator-owned deterministic transcript frontmatter', () => {
+  const meta = {
+    idx: 1,
+    hash6: 'abc123',
+    chunkTotal: 3,
+    transcriptSource: 'claude-code',
+    transcriptId: 'session-uuid',
+    inferredDate: '2026-05-15',
+  };
+
+  test('collectChildPutPageSlugs pairs each ref back to the writing job', async () => {
+    const refs = await collectChildPutPageSlugs(
+      engine as any, [1001], new Map([[1001, { ...meta, chunkTotal: 1 }]]), 'mybrain',
+    );
+    expect(refs.length).toBeGreaterThan(0);
+    for (const r of refs) {
+      expect(r.jobId).toBe(1001);
+      expect(r.source_id).toBe('mybrain'); // #1586: cycle source, never hardcoded 'default'
+    }
+  });
+
+  test('slug collision across children attributes the LAST writer (matches surviving putPage)', async () => {
+    const db = (engine as any).db;
+    // Jobs 1001 then 1002 write the same slug; the pages row would hold
+    // 1002's content (last put_page wins), so the ref must carry jobId 1002.
+    await db.query(
+      `INSERT INTO subagent_tool_executions (job_id, message_idx, tool_use_id, tool_name, status, input)
+       VALUES (1001, 9, 'tool_dup_a', 'brain_put_page', 'complete', $1::jsonb)`,
+      [JSON.stringify({ slug: 'wiki/agents/test/collision', body: 'first' })],
+    );
+    await db.query(
+      `INSERT INTO subagent_tool_executions (job_id, message_idx, tool_use_id, tool_name, status, input)
+       VALUES (1002, 9, 'tool_dup_b', 'brain_put_page', 'complete', $1::jsonb)`,
+      [JSON.stringify({ slug: 'wiki/agents/test/collision', body: 'second' })],
+    );
+    const refs = await collectChildPutPageSlugs(engine as any, [1001, 1002], new Map());
+    const hit = refs.find((r: { slug: string }) => r.slug === 'wiki/agents/test/collision');
+    expect(hit?.jobId).toBe(1002);
+  });
+
+  test('stampDreamProvenance merges the transcript metadata into DB frontmatter', async () => {
+    const slug = 'wiki/originals/ideas/2026-07-17-transcript-meta-abc123';
+    await engine.putPage(slug, {
+      type: 'note',
+      title: 'Meta stamp',
+      compiled_truth: 'body',
+      timeline: '',
+      frontmatter: { keep_me: 'yes', transcript_id: 'subagent-drift' },
+    });
+    await stampDreamProvenance(
+      engine as any,
+      [{ slug, source_id: 'default', jobId: 42 }],
+      '2026-07-17',
+      new Map([[42, meta]]),
+    );
+    const rows = await engine.executeRaw<{ fm: Record<string, unknown> }>(
+      `SELECT frontmatter AS fm FROM pages WHERE slug = $1`, [slug],
+    );
+    const fm = rows[0].fm as Record<string, unknown>;
+    expect(fm.dream_generated).toBe(true);
+    expect(fm.dream_cycle_date).toBe('2026-07-17');
+    expect(fm.transcript_id).toBe('session-uuid'); // orchestrator wins over subagent drift
+    expect(fm.transcript_hash).toBe('abc123');
+    expect(fm.transcript_source).toBe('claude-code');
+    expect(fm.chunk).toBe('2/3');
+    expect(fm.date).toBe('2026-05-15');
+    expect(fm.keep_me).toBe('yes'); // subagent-owned keys survive
+  });
+
+  test('single-chunk children with no inferredDate stamp only the applicable fields', async () => {
+    const slug = 'wiki/originals/ideas/2026-07-17-minimal-meta-abc123';
+    await engine.putPage(slug, {
+      type: 'note', title: 'Minimal', compiled_truth: 'b', timeline: '', frontmatter: {},
+    });
+    await stampDreamProvenance(
+      engine as any,
+      [{ slug, source_id: 'default', jobId: 43 }],
+      '2026-07-17',
+      new Map([[43, { ...meta, chunkTotal: 1, transcriptSource: null, inferredDate: null }]]),
+    );
+    const rows = await engine.executeRaw<{ fm: Record<string, unknown> }>(
+      `SELECT frontmatter AS fm FROM pages WHERE slug = $1`, [slug],
+    );
+    const fm = rows[0].fm as Record<string, unknown>;
+    expect(fm.transcript_id).toBe('session-uuid');
+    expect(fm.chunk).toBeUndefined();
+    expect(fm.transcript_source).toBeUndefined();
+    expect(fm.date).toBeUndefined();
+  });
+});
@@ -302,6 +302,7 @@ describe('judgeSignificance', () => {
      content: 'A short conversation about something interesting.',
      basename: 'x',
      inferredDate: null,
+      transcriptSource: null,
    };
  }

@@ -415,6 +416,7 @@ describe('judgeSignificance — UTF-16 safety (v0.41.13)', () => {
      content,
      basename: 'long',
      inferredDate: null,
+      transcriptSource: null,
    };
  }

@@ -45,6 +45,7 @@ const FIXTURE_TRANSCRIPT: DiscoveredTranscript = {
  content: 'Synthetic transcript content for gateway-adapter parity tests.',
  contentHash: 'sha-fixture-1',
  inferredDate: '2026-05-24',
+  transcriptSource: null,
 };

 describe('makeJudgeClient — construction-time provider probe', () => {
@@ -0,0 +1,109 @@
+/**
+ * #2285 — transcript metadata discovery.
+ *
+ * Pins the two discovery-side additions:
+ *   1. `transcriptSource` — derived from the `<source>/<date>/<file>` path
+ *      layout; null for ad-hoc inputs that don't match.
+ *   2. Content-based date inference — the `| First message | <ISO> |` row in
+ *      the transcript's `## Metadata` table wins over the filename-regex
+ *      date (stable across mtime-restamping re-syncs); filename is the
+ *      fallback.
+ *
+ * Pure filesystem; no engine, no LLM.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import {
+  discoverTranscripts,
+  readSingleTranscript,
+  deriveTranscriptSource,
+  inferContentDate,
+} from '../../src/core/cycle/transcript-discovery.ts';
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'gbrain-transcript-meta-'));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function write(relPath: string, body: string): string {
+  const full = join(tmpDir, relPath);
+  mkdirSync(dirname(full), { recursive: true });
+  writeFileSync(full, body);
+  return full;
+}
+
+const FILLER = 'User: hello world. '.repeat(200);
+const METADATA_BLOCK =
+  '## Metadata\n\n| Key | Value |\n| --- | --- |\n| First message | 2026-05-15T03:51:11.584Z |\n\n';
+
+describe('deriveTranscriptSource', () => {
+  test('extracts the source slug from <source>/<date>/<file> layout', () => {
+    expect(deriveTranscriptSource('/corpus/claude-code/2026-06-12/abc.md')).toBe('claude-code');
+    expect(deriveTranscriptSource('/corpus/voice-notes/2026-06-12/xyz.md')).toBe('voice-notes');
+  });
+
+  test('null when the parent dir is not a date dir or grandparent is not a slug', () => {
+    expect(deriveTranscriptSource('/corpus/flat-file.md')).toBeNull();
+    expect(deriveTranscriptSource('/corpus/claude-code/not-a-date/abc.md')).toBeNull();
+    expect(deriveTranscriptSource('/corpus/Not A Slug/2026-06-12/abc.md')).toBeNull();
+  });
+});
+
+describe('inferContentDate', () => {
+  test('parses the | First message | row', () => {
+    expect(inferContentDate(METADATA_BLOCK)).toBe('2026-05-15');
+  });
+  test('null when absent', () => {
+    expect(inferContentDate(FILLER)).toBeNull();
+  });
+});
+
+describe('discoverTranscripts — transcriptSource + date cascade', () => {
+  test('populates transcriptSource per file; null for flat files', () => {
+    write('claude-code/2026-06-12/aaaa.md', FILLER);
+    write('2026-06-12-flat.md', FILLER);
+    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
+    const byBase = new Map(out.map(t => [t.basename, t.transcriptSource]));
+    expect(byBase.get('aaaa')).toBe('claude-code');
+    expect(byBase.get('2026-06-12-flat')).toBeNull();
+  });
+
+  test('content First-message date wins over the filename date', () => {
+    write('2026-01-01-named.md', METADATA_BLOCK + FILLER);
+    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
+    expect(out).toHaveLength(1);
+    expect(out[0].inferredDate).toBe('2026-05-15');
+  });
+
+  test('filename date remains the fallback when content has no metadata row', () => {
+    write('2026-01-01-named.md', FILLER);
+    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
+    expect(out[0].inferredDate).toBe('2026-01-01');
+  });
+
+  test('date filter matches on the content date for UUID-named transcripts', () => {
+    write('claude-code/2026-05-15/uuid-basename.md', METADATA_BLOCK + FILLER);
+    const hit = discoverTranscripts({ corpusDir: tmpDir, minChars: 100, date: '2026-05-15' });
+    expect(hit).toHaveLength(1);
+    const miss = discoverTranscripts({ corpusDir: tmpDir, minChars: 100, date: '2026-05-16' });
+    expect(miss).toHaveLength(0);
+  });
+});
+
+describe('readSingleTranscript — same metadata surface', () => {
+  test('carries transcriptSource and prefers the content date', () => {
+    const p = write('claude-code/2026-05-15/2026-01-01-single.md', METADATA_BLOCK + FILLER);
+    const t = readSingleTranscript(p, { minChars: 100 });
+    expect(t).not.toBeNull();
+    expect(t!.transcriptSource).toBe('claude-code');
+    expect(t!.inferredDate).toBe('2026-05-15');
+  });
+});
@@ -78,8 +78,6 @@ describe('v0.36.1.x #1077 — admin register-client supports PKCE public clients
    // (under either name) from req.body. Pin the fallback pattern so the
    // PKCE-fix regression contract stays load-bearing.
    expect(src).toMatch(/req\.body[^;]*scopes\s*\?\?\s*[^;]*scope\b/);
-    expect(src).toMatch(/req\.body[^;]*source_id\s*\?\?\s*[^;]*sourceId\b/);
-    expect(src).toMatch(/req\.body[^;]*federated_read\s*\?\?\s*[^;]*federatedRead\b/);
    // v0.41.3 (T4 atomicity fix, codex F4): admin endpoint now validates
    // tokenEndpointAuthMethod via the shared validator and passes it to
    // registerClientManual as a positional arg. Pre-v0.41.3 the route did
@@ -89,7 +87,6 @@ describe('v0.36.1.x #1077 — admin register-client supports PKCE public clients
    // UPDATE block (the regex deliberately asserts the post-insert UPDATE
    // is GONE).
    expect(src).toMatch(/validateTokenEndpointAuthMethod\(tokenEndpointAuthMethod\)/);
-    expect(src).toMatch(/normalizeAdminClientSourceScope\(/);
    expect(src).toMatch(/registerClientManual\([^)]*validatedAuthMethod[^)]*\)/);
    // Regression guard: post-insert UPDATE flipping client_secret_hash to
    // NULL based on a runtime check is exactly the non-atomic pattern T4
@@ -270,26 +267,3 @@ describe('v0.42.43.0 #2095 — volunteer-events sink + cycle purge wiring (struc
    expect(src).toMatch(/purged_volunteer_events_count/);
  });
 });
-
-describe('#1490 + #1036 — admin Register Agent form exposes source scope + redirect URIs', () => {
-  test('Agents.tsx RegisterModal sends source_id + federated_read in the POST body (#1490)', () => {
-    const src = readFileSync('admin/src/pages/Agents.tsx', 'utf8');
-    expect(src).toMatch(/source_id:\s*sourceId/);
-    expect(src).toMatch(/federated_read:\s*federatedRead/);
-    // The source list comes from the requireAdmin-gated endpoint, not a hardcoded 'default'.
-    expect(src).toMatch(/api\.sources\(\)/);
-  });
-
-  test('serve-http.ts serves /admin/api/sources behind requireAdmin (#1490)', () => {
-    const src = readFileSync('src/commands/serve-http.ts', 'utf8');
-    expect(src).toMatch(/app\.get\('\/admin\/api\/sources',\s*requireAdmin/);
-  });
-
-  test('Agents.tsx RegisterModal sends redirectUris + authorization_code grants when URIs are entered (#1036)', () => {
-    const src = readFileSync('admin/src/pages/Agents.tsx', 'utf8');
-    // One-per-line textarea split into an array...
-    expect(src).toMatch(/redirectUris\.split\('\\n'\)/);
-    // ...included in the body with the CLI's grant-type inference convention.
-    expect(src).toMatch(/redirectUris:\s*uris,\s*grantTypes:\s*\['authorization_code',\s*'refresh_token'\]/);
-  });
-});
@@ -125,30 +125,6 @@ describe('client registration', () => {
    expect(client!.client_name).toBe('test-agent');
  });

-  test('registerClientManual persists source_id and federated_read into AuthInfo', async () => {
-    await sql`
-      INSERT INTO sources (id, name) VALUES (${'team-a'}, ${'Team A'}), (${'team-b'}, ${'Team B'})
-      ON CONFLICT DO NOTHING
-    `;
-    const { clientId, clientSecret } = await provider.registerClientManual(
-      'source-scoped-test',
-      ['client_credentials'],
-      'read write',
-      [],
-      'team-a',
-      ['team-a', 'team-b'],
-    );
-
-    const tokens = await provider.exchangeClientCredentials(clientId, clientSecret!, 'read');
-    const authInfo = await provider.verifyAccessToken(tokens.access_token) as {
-      sourceId?: string;
-      allowedSources?: string[];
-    };
-
-    expect(authInfo.sourceId).toBe('team-a');
-    expect(authInfo.allowedSources).toEqual(['team-a', 'team-b']);
-  });
-
  test('getClient returns undefined for unknown client', async () => {
    const client = await provider.clientsStore.getClient('nonexistent');
    expect(client).toBeUndefined();
@@ -216,17 +216,21 @@ describe('progress reporter', () => {
  });

  test('only one process-level signal handler installed across many reporters', () => {
-    // Baseline: one handler already installed by prior tests in this file.
+    // Baseline: one handler already installed by prior tests in this file, and
+    // possibly live reporters from OTHER test files sharing this bun process
+    // (shard composition is not this test's invariant — assert the delta, not
+    // an absolute zero, or shard reshuffles make this fail spuriously).
    const installedBefore = __signalHandlerInstalledForTest();
+    const liveBefore = __liveReporterCountForTest();
    const { stream } = sink(false);
    for (let i = 0; i < 50; i++) {
      const p = createProgress({ mode: 'json', stream, minIntervalMs: 0, minItems: 1 });
      p.start(`phase_${i}`, 1);
      p.finish();
    }
-    // After 50 reporter lifecycles, still exactly one handler and zero leaked live entries.
+    // After 50 reporter lifecycles, still exactly one handler and zero NET leaked live entries.
    expect(__signalHandlerInstalledForTest()).toBe(installedBefore || true);
-    expect(__liveReporterCountForTest()).toBe(0);
+    expect(__liveReporterCountForTest()).toBe(liveBefore);
  });

  test('startHeartbeat() fires heartbeats and stop() clears', async () => {