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
40 changed files with 521 additions and 1065 deletions
@@ -71,8 +71,8 @@ GBrain is designed to be installed and operated by an AI agent. The fastest path

 If you don't already have an AI agent platform running, start with one of these. Both are designed to read GBrain's install protocol and execute it:

- **[OpenClaw](https://github.com/openclaw/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
- **[Hermes](https://github.com/NousResearch/hermes-agent)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)
+- **[OpenClaw](https://github.com/openclawagents/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
+- **[Hermes](https://github.com/openclawagents/hermes)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)

 Then paste this into your agent:

@@ -131,9 +131,7 @@ into gbrain so other clients can scaffold it. Default behavior:
  `~/.gbrain/harvest-private-patterns.txt` plus built-in defaults
  (canonical private fork name, common email regex, Slack channel pattern). Any
  match → rollback (delete the harvested files) and exit non-zero.
- `openclaw.plugin.json` updated with the new slug, sorted. Harvest must preserve
-  the top-level OpenClaw-native plugin fields (`id`, `configSchema`, `contracts`)
-  because OpenClaw validates those before it can install the package.
+- `openclaw.plugin.json` updated with the new slug, sorted.
 - `--no-lint` bypasses the linter (after a manual editorial scrub).

 Use the `skillpack-harvest` skill (its companion editorial workflow)
@@ -233,14 +233,13 @@ keep it or `git checkout` to throw it away. Nothing is committed for you.

 **For a skill that ships with gbrain** (anything under the gbrain repo's own
 `skills/`): SkillOpt refuses to overwrite it by default and writes the winner to
-`skills/<name>/skillopt/proposed.md` instead (while keeping `best.md` as the
-optimizer's current-best pointer), so an optimization pass can never silently
-mutate a skill other people depend on. Two ways to handle that:
+`skills/<name>/skillopt/best.md` instead, so an optimization pass can never
+silently mutate a skill other people depend on. Two ways to handle that:

 ```bash
 # See the proposed improvement without touching SKILL.md (works for ANY skill):
 gbrain skillopt meeting-prep --split 1:1:1 --no-mutate
-# → writes skills/meeting-prep/skillopt/proposed.md, updates best.md, and prints the proposal path.
+# → writes skills/meeting-prep/skillopt/best.md (the proposed rewrite), prints its path. Copy what you want.

 # Actually rewrite a bundled skill (explicit opt-in + an independent held-out set):
 gbrain skillopt brain-ops --split 1:1:1 --allow-mutate-bundled \
@@ -1565,8 +1565,8 @@ GBrain is designed to be installed and operated by an AI agent. The fastest path

 If you don't already have an AI agent platform running, start with one of these. Both are designed to read GBrain's install protocol and execute it:

- **[OpenClaw](https://github.com/openclaw/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
- **[Hermes](https://github.com/NousResearch/hermes-agent)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)
+- **[OpenClaw](https://github.com/openclawagents/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
+- **[Hermes](https://github.com/openclawagents/hermes)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)

 Then paste this into your agent:

@@ -1,5 +1,4 @@
 {
-  "id": "gbrain-context-engine",
  "name": "gbrain",
  "version": "0.32.3.0",
  "description": "Personal knowledge brain with Postgres + pgvector hybrid search",
@@ -266,5 +266,4 @@ editorial pass.
  (e.g. `src/commands/<slug>.ts` if the host SKILL.md declares it
  in frontmatter)
 - gbrain's `openclaw.plugin.json` — adds the slug to `skills:`
-  array, sorted alphabetically, without removing OpenClaw-native plugin fields
-  like `id`, `configSchema`, or `contracts`
+  array, sorted alphabetically
@@ -57,8 +57,6 @@ This mode guarantees:
 - `skills/manifest.json` lists every skill directory
 - `skills/RESOLVER.md` references every skill in the manifest
 - `openclaw.plugin.json` `skills[]` round-trips with both
- `openclaw.plugin.json` keeps OpenClaw install-required native plugin fields
-  (`id`, object `configSchema`, and `contracts.contextEngines` when applicable)
 - No MECE violations (duplicate triggers across skills)

 ### Phases
@@ -74,7 +72,7 @@ This mode guarantees:
 ### Automation

 ```bash
-bun test test/skills-conformance.test.ts test/resolver.test.ts test/openclaw-plugin-manifest.test.ts
+bun test test/skills-conformance.test.ts test/resolver.test.ts
 ```

 The CI-gated check is the package.json `test` script.
@@ -54,7 +54,7 @@ export function bigintToStringReplacer(_key: string, value: unknown): unknown {
 }

 // CLI-only commands that bypass the operation layer
-export const CLI_ONLY = new Set(['init', 'reinit-pglite', 'upgrade', 'post-upgrade', 'check-update', 'integrations', 'publish', 'check-backlinks', 'lint', 'report', 'import', 'export', 'files', 'embed', 'serve', 'call', 'config', 'doctor', 'migrate', 'eval', 'sync', 'extract', 'extract-conversation-facts', 'enrich', 'features', 'autopilot', 'graph-query', 'jobs', 'agent', 'apply-migrations', 'skillpack-check', 'skillpack', 'resolvers', 'integrity', 'repair-jsonb', 'orphans', 'maintain', 'sources', 'mounts', 'dream', 'check-resolvable', 'routing-eval', 'skillify', 'smoke-test', 'providers', 'storage', 'repos', 'code-def', 'code-refs', 'reindex', 'reindex-code', 'reindex-frontmatter', 'code-callers', 'code-callees', 'reconcile-links', 'frontmatter', 'auth', 'friction', 'claw-test', 'book-mirror', 'takes', 'think', 'salience', 'anomalies', 'calibration', 'transcripts', 'models', 'remote', 'recall', 'forget', 'edges-backfill', 'cache', 'ze-switch', 'founder', 'brainstorm', 'lsd', 'schema', 'capture', 'onboard', 'conversation-parser', 'status', 'connect', 'skillopt', 'quarantine', 'self-upgrade', 'advisor', 'watch', 'reindex-search-vector']);
+export const CLI_ONLY = new Set(['init', 'reinit-pglite', 'upgrade', 'post-upgrade', 'check-update', 'integrations', 'publish', 'check-backlinks', 'lint', 'report', 'import', 'export', 'files', 'embed', 'serve', 'call', 'config', 'doctor', 'migrate', 'eval', 'sync', 'extract', 'extract-conversation-facts', 'enrich', 'features', 'autopilot', 'graph-query', 'jobs', 'agent', 'apply-migrations', 'skillpack-check', 'skillpack', 'resolvers', 'integrity', 'repair-jsonb', 'orphans', 'sources', 'mounts', 'dream', 'check-resolvable', 'routing-eval', 'skillify', 'smoke-test', 'providers', 'storage', 'repos', 'code-def', 'code-refs', 'reindex', 'reindex-code', 'reindex-frontmatter', 'code-callers', 'code-callees', 'reconcile-links', 'frontmatter', 'auth', 'friction', 'claw-test', 'book-mirror', 'takes', 'think', 'salience', 'anomalies', 'calibration', 'transcripts', 'models', 'remote', 'recall', 'forget', 'edges-backfill', 'cache', 'ze-switch', 'founder', 'brainstorm', 'lsd', 'schema', 'capture', 'onboard', 'conversation-parser', 'status', 'connect', 'skillopt', 'quarantine', 'self-upgrade', 'advisor', 'watch', 'reindex-search-vector']);
 // CLI-only commands whose handlers print their own --help text. These are
 // excluded from the generic short-circuit so detailed per-command and
 // per-subcommand usage stays reachable.
@@ -78,8 +78,6 @@ const CLI_ONLY_SELF_HELP = new Set([
  'capture',
  // v0.42 self-upgrade ships its own usage (flags + the agent-skill story).
  'self-upgrade',
-  // maintain (#3015) prints its own usage block (modes + not-auto-applied list).
-  'maintain',
  // v0.43 (#2095): watch ships WATCH_HELP (flags + the stdin-turn protocol).
  'watch',
  // v0.37 fix wave (Lane D.4 + CDX2-12): sync's --no-embed flag was
@@ -1759,11 +1757,6 @@ async function handleCliOnly(command: string, args: string[]) {
        await runOrphans(engine, args);
        break;
      }
-      case 'maintain': {
-        const { runMaintain } = await import('./commands/maintain.ts');
-        await runMaintain(engine, args);
-        break;
-      }
      // v0.32.7 CJK wave — post-upgrade markdown re-chunk sweep.
      // v0.36 Phase 3 wave — `gbrain reindex --multimodal` re-embeds content_chunks
      // into the unified Voyage multimodal-3 column.
@@ -581,7 +581,7 @@ async function embedPage(
  for (let j = 0; j < toEmbed.length; j++) {
    embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
  }
-  const updated: ChunkInput[] = chunks.map(c => preserveCodeMetadata(c, {
+  const updated: ChunkInput[] = chunks.map(c => ({
    chunk_index: c.chunk_index,
    chunk_text: c.chunk_text,
    chunk_source: c.chunk_source,
@@ -605,31 +605,6 @@ async function embedPage(
  slog(`${slug}: embedded ${toEmbed.length} chunks`);
 }

-/**
- * Carry code-chunk metadata (language, symbol_name, symbol_type, line range,
- * parent scope, doc comment, qualified name) from a loaded Chunk back into a
- * ChunkInput destined for upsertChunks.
- *
- * Issue #769: every re-embed used to strip these fields, and upsertChunks
- * overwrites (does not COALESCE) the metadata columns from EXCLUDED, so
- * each pass clobbered code-def's primary index to NULL. Pulling the
- * preservation into one helper keeps the three re-embed call sites
- * (embedPage, embedAll non-stale, embedAllStale) in lock-step.
- */
-function preserveCodeMetadata(loaded: any, base: ChunkInput): ChunkInput {
-  return {
-    ...base,
-    language: loaded.language ?? undefined,
-    symbol_name: loaded.symbol_name ?? undefined,
-    symbol_type: loaded.symbol_type ?? undefined,
-    start_line: loaded.start_line ?? undefined,
-    end_line: loaded.end_line ?? undefined,
-    parent_symbol_path: loaded.parent_symbol_path ?? undefined,
-    doc_comment: loaded.doc_comment ?? undefined,
-    symbol_name_qualified: loaded.symbol_name_qualified ?? undefined,
-  };
-}
-
 async function embedAll(
  engine: BrainEngine,
  staleOnly: boolean,
@@ -742,10 +717,8 @@ async function embedAll(
      for (let j = 0; j < toEmbed.length; j++) {
        embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
      }
-      // Preserve ALL chunks, only update embeddings for stale ones.
-      // preserveCodeMetadata threads code-chunk metadata (#769) so re-embed
-      // doesn't clobber language/symbol_name/symbol_type to NULL.
-      const updated: ChunkInput[] = chunks.map(c => preserveCodeMetadata(c, {
+      // Preserve ALL chunks, only update embeddings for stale ones
+      const updated: ChunkInput[] = chunks.map(c => ({
        chunk_index: c.chunk_index,
        chunk_text: c.chunk_text,
        chunk_source: c.chunk_source,
@@ -1039,10 +1012,7 @@ async function embedAllStale(
          for (let j = 0; j < stale.length; j++) {
            staleIdxToEmbedding.set(stale[j].chunk_index, embeddings[j]);
          }
-          // preserveCodeMetadata threads code-chunk metadata (#769) so the
-          // autopilot --stale path doesn't clobber language/symbol_name/etc
-          // to NULL on every cycle.
-          const merged: ChunkInput[] = existing.map(c => preserveCodeMetadata(c, {
+          const merged: ChunkInput[] = existing.map(c => ({
            chunk_index: c.chunk_index,
            chunk_text: c.chunk_text,
            chunk_source: c.chunk_source,
@@ -1651,7 +1651,7 @@ async function extractTimelineFromDB(
 * make re-extraction idempotent). EVERY processed page is stamped, including
 * zero-link pages — they WERE processed.
 */
-export async function extractStaleFromDB(
+async function extractStaleFromDB(
  engine: BrainEngine,
  opts: {
    dryRun: boolean;
@@ -1,224 +0,0 @@
-/**
- * gbrain maintain — conservative self-healing maintenance.
- *
- * This command automates the safe parts of the operator runbook:
- *   - stale link/timeline extraction
- *   - stale per-source dream cycles when doctor reports cycle_freshness
- *
- * It deliberately does NOT mutate source files, apply schema-pack upgrades, or
- * invent semantic hub links. Those need review or a separate command with an
- * auditable proposal surface.
- */
-
-import { existsSync } from 'fs';
-import type { BrainEngine } from '../core/engine.ts';
-import type { BrainHealth } from '../core/types.ts';
-import { buildChecks, computeDoctorReport, type DoctorReport, type Check } from './doctor.ts';
-import { extractStaleFromDB } from './extract.ts';
-import { runCycle, type CycleReport } from '../core/cycle.ts';
-
-type ActionStatus = 'ok' | 'would_apply' | 'applied' | 'blocked' | 'skipped';
-
-export interface MaintenanceAction {
-  name: string;
-  status: ActionStatus;
-  message: string;
-  details?: Record<string, unknown>;
-}
-
-export interface MaintainOptions {
-  json: boolean;
-  safe: boolean;
-  dryRun: boolean;
-  help: boolean;
-}
-
-export interface MaintainReport {
-  mode: 'dry-run' | 'safe';
-  before: {
-    health: BrainHealth;
-    doctor: DoctorReport;
-  };
-  actions: MaintenanceAction[];
-  after: {
-    health: BrainHealth;
-    doctor: DoctorReport;
-  };
-}
-
-export function parseMaintainArgs(args: string[]): MaintainOptions {
-  const safe = args.includes('--safe');
-  return {
-    json: args.includes('--json'),
-    safe,
-    dryRun: args.includes('--dry-run') || !safe,
-    help: args.includes('--help') || args.includes('-h'),
-  };
-}
-
-export function extractCycleFreshnessSourceIds(checks: Check[]): string[] {
-  const ids = new Set<string>();
-  for (const check of checks) {
-    if (check.name !== 'cycle_freshness' || check.status === 'ok') continue;
-    const re = /Source '([^']+)' last cycled/g;
-    for (const match of check.message.matchAll(re)) {
-      const id = match[1]?.trim();
-      if (id) ids.add(id);
-    }
-  }
-  return [...ids].sort();
-}
-
-async function buildDoctorReport(engine: BrainEngine): Promise<DoctorReport> {
-  const checks = await buildChecks(engine, ['--json', '--scope=brain']);
-  return computeDoctorReport(checks);
-}
-
-async function runStaleExtraction(
-  engine: BrainEngine,
-  beforeHealth: BrainHealth,
-  dryRun: boolean,
-): Promise<MaintenanceAction> {
-  if (beforeHealth.stale_pages <= 0) {
-    return { name: 'extract_stale', status: 'ok', message: 'No stale pages.' };
-  }
-
-  if (dryRun) {
-    return {
-      name: 'extract_stale',
-      status: 'would_apply',
-      message: `Would run DB-backed stale extraction for ${beforeHealth.stale_pages} page(s).`,
-      details: { stale_pages: beforeHealth.stale_pages },
-    };
-  }
-
-  const result = await extractStaleFromDB(engine, {
-    dryRun: false,
-    jsonMode: false,
-    includeFrontmatter: false,
-    catchUp: false,
-  });
-
-  return {
-    name: 'extract_stale',
-    status: 'applied',
-    message: `Processed ${result.pagesProcessed} stale page(s); ${result.staleRemaining} remain.`,
-    details: {
-      links_created: result.linksCreated,
-      timeline_created: result.timelineCreated,
-      pages_processed: result.pagesProcessed,
-      stale_remaining: result.staleRemaining,
-    },
-  };
-}
-
-async function runCycleFreshnessMaintenance(
-  engine: BrainEngine,
-  beforeDoctor: DoctorReport,
-  dryRun: boolean,
-): Promise<MaintenanceAction[]> {
-  const sourceIds = extractCycleFreshnessSourceIds(beforeDoctor.checks);
-  if (sourceIds.length === 0) {
-    return [{ name: 'cycle_freshness', status: 'ok', message: 'All sources cycled recently.' }];
-  }
-
-  if (dryRun) {
-    return sourceIds.map((sourceId) => ({
-      name: 'cycle_freshness',
-      status: 'would_apply',
-      message: `Would run source-scoped dream cycle for ${sourceId}.`,
-      details: { source_id: sourceId },
-    }));
-  }
-
-  const sources = await engine.listAllSources();
-  const actions: MaintenanceAction[] = [];
-
-  for (const sourceId of sourceIds) {
-    const source = sources.find((s) => s.id === sourceId);
-    const localPath = source?.local_path ?? null;
-    const brainDir = localPath && existsSync(localPath) ? localPath : null;
-    const report: CycleReport = await runCycle(engine, {
-      brainDir,
-      dryRun: false,
-      pull: false,
-      sourceId,
-    });
-    actions.push({
-      name: 'cycle_freshness',
-      status: report.status === 'failed' ? 'blocked' : 'applied',
-      message: `Ran source-scoped dream cycle for ${sourceId}: ${report.status}.`,
-      details: {
-        source_id: sourceId,
-        brain_dir: brainDir,
-        cycle_status: report.status,
-        phases: report.phases.map((p) => ({ phase: p.phase, status: p.status })),
-      },
-    });
-  }
-
-  return actions;
-}
-
-export async function runMaintain(engine: BrainEngine, args: string[]): Promise<MaintainReport | void> {
-  const opts = parseMaintainArgs(args);
-  if (opts.help) {
-    console.log(`Usage: gbrain maintain [--safe] [--dry-run] [--json]
-
-Conservative self-healing maintenance.
-
-Modes:
-  --dry-run   Preview safe actions without writes. Default when --safe is absent.
-  --safe      Apply safe actions: stale extraction and source cycle freshness.
-  --json      Emit a structured before/action/after report.
-
-Not auto-applied:
-  source-file frontmatter fixes, schema-pack upgrades, atom-pack changes,
-  semantic hub-link guesses, and destructive cleanup.
-`);
-    return;
-  }
-
-  const beforeHealth = await engine.getHealth();
-  const beforeDoctor = await buildDoctorReport(engine);
-  const actions: MaintenanceAction[] = [];
-
-  actions.push(await runStaleExtraction(engine, beforeHealth, opts.dryRun));
-  actions.push(...await runCycleFreshnessMaintenance(engine, beforeDoctor, opts.dryRun));
-
-  const afterHealth = await engine.getHealth();
-  const afterDoctor = await buildDoctorReport(engine);
-  const report: MaintainReport = {
-    mode: opts.dryRun ? 'dry-run' : 'safe',
-    before: { health: beforeHealth, doctor: beforeDoctor },
-    actions,
-    after: { health: afterHealth, doctor: afterDoctor },
-  };
-
-  if (opts.json) {
-    console.log(JSON.stringify(report, null, 2));
-  } else {
-    printMaintainReport(report);
-  }
-  return report;
-}
-
-function printMaintainReport(report: MaintainReport): void {
-  console.log(`GBrain maintain (${report.mode})`);
-  console.log(
-    `Before: brain_score=${Math.round(report.before.health.brain_score)}/100 ` +
-    `stale=${report.before.health.stale_pages} islands=${report.before.health.orphan_pages} ` +
-    `doctor=${report.before.doctor.status}`,
-  );
-  for (const action of report.actions) {
-    console.log(`  ${action.status}: ${action.name} — ${action.message}`);
-  }
-  console.log(
-    `After:  brain_score=${Math.round(report.after.health.brain_score)}/100 ` +
-    `stale=${report.after.health.stale_pages} islands=${report.after.health.orphan_pages} ` +
-    `doctor=${report.after.doctor.status}`,
-  );
-  if (report.mode === 'dry-run') {
-    console.log('Run `gbrain maintain --safe` to apply safe actions.');
-  }
-}
@@ -15,11 +15,6 @@
 import type { BrainEngine } from '../core/engine.ts';
 import { createProgress, startHeartbeat } from '../core/progress.ts';
 import { getCliOptions, cliOptsToProgressOptions } from '../core/cli-options.ts';
-import {
-  shouldExcludeFromOrphanReporting,
-  loadOrphanPolicyOverrides,
-  type OrphanPolicyOverrides,
-} from '../core/orphan-policy.ts';

 // --- Types ---

@@ -37,14 +32,65 @@ export interface OrphanResult {
  excluded: number;
 }

+// --- Filter constants ---
+
+/** Slug suffixes that are always auto-generated root files */
+const AUTO_SUFFIX_PATTERNS = ['/_index', '/log'];
+
+/** Page slugs that are pseudo-pages by convention */
+const PSEUDO_SLUGS = new Set(['_atlas', '_index', '_stats', '_orphans', '_scratch', 'claude']);
+
+/** Slug segment that marks raw sources */
+const RAW_SEGMENT = '/raw/';
+
+/** Slug prefixes where no inbound links is expected */
+const DENY_PREFIXES = [
+  'output/',
+  'dashboards/',
+  'scripts/',
+  'templates/',
+  'openclaw/config/',
+];
+
+/** First slug segments where no inbound links is expected */
+const FIRST_SEGMENT_EXCLUSIONS = new Set([
+  'scratch',
+  'thoughts',
+  'catalog',
+  'entities',
+  'raw',
+  'atoms',
+  'skills',
+]);
+
 // --- Filter logic ---

 /**
 * Returns true if a slug should be excluded from orphan reporting by default.
 * These are pages where having no inbound links is expected / not a content problem.
 */
-export function shouldExclude(slug: string, overrides?: OrphanPolicyOverrides): boolean {
-  return shouldExcludeFromOrphanReporting(slug, overrides);
+export function shouldExclude(slug: string): boolean {
+  // Pseudo-pages (exact match)
+  if (PSEUDO_SLUGS.has(slug)) return true;
+
+  // Auto-generated suffix patterns
+  for (const suffix of AUTO_SUFFIX_PATTERNS) {
+    if (slug.endsWith(suffix)) return true;
+  }
+
+  // Raw source slugs
+  if (slug.includes(RAW_SEGMENT)) return true;
+
+  // Deny-prefix slugs
+  for (const prefix of DENY_PREFIXES) {
+    if (slug.startsWith(prefix)) return true;
+  }
+
+  // First-segment exclusions
+  const firstSegment = slug.split('/')[0];
+  if (FIRST_SEGMENT_EXCLUSIONS.has(firstSegment)) return true;
+
+  return false;
 }

 /**
@@ -110,7 +156,6 @@ export async function findOrphans(
  let allOrphans: { slug: string; title: string; domain: string | null }[];
  let total: number;
  let excludedAll: number;
-  const overrides = includePseudo ? undefined : await loadOrphanPolicyOverrides(engine);
  try {
    allOrphans = await engine.findOrphanPages(
      sourceIds ? { sourceIds } : sourceId ? { sourceId } : undefined,
@@ -139,7 +184,7 @@ export async function findOrphans(
    total = liveRows.length;
    excludedAll = includePseudo
      ? 0
-      : liveRows.reduce((n, r) => n + (shouldExclude(r.slug, overrides) ? 1 : 0), 0);
+      : liveRows.reduce((n, r) => n + (shouldExclude(r.slug) ? 1 : 0), 0);
  } finally {
    stopHb();
    progress.finish();
@@ -147,7 +192,7 @@ export async function findOrphans(

  const filtered = includePseudo
    ? allOrphans
-    : allOrphans.filter(row => !shouldExclude(row.slug, overrides));
+    : allOrphans.filter(row => !shouldExclude(row.slug));

  const orphans: OrphanPage[] = filtered.map(row => ({
    slug: row.slug,
@@ -54,7 +54,6 @@ import {
 import {
  generatePerChunkSynopsis,
  SYNOPSIS_PROMPT_VERSION,
-  SYNOPSIS_DOC_MAX_CHARS,
  type GeneratePerChunkSynopsisResult,
 } from './page-summary.ts';
 import {
@@ -104,17 +103,8 @@ function getEmbeddingModelTag(): string {
 export function computeCorpusGeneration(args: {
  crMode: CRMode;
  haikuModel: string;
-  /**
-   * Resolved `SYNOPSIS_DOC_MAX_CHARS` for per_chunk_synopsis runs. When
-   * present, folded into the hash so changes to
-   * `GBRAIN_SYNOPSIS_DOC_MAX_CHARS` invalidate the prior cache cleanly.
-   * Omit for `crMode !== 'per_chunk_synopsis'` — title / none modes
-   * don't consult the cap and the field stays out of the hash for
-   * back-compat with pre-cap embeddings.
-   */
-  synopsisDocMaxChars?: number;
 }): string {
-  const h = createHash('sha256')
+  return createHash('sha256')
    .update(args.crMode)
    .update('|')
    .update(String(SYNOPSIS_PROMPT_VERSION))
@@ -123,11 +113,9 @@ export function computeCorpusGeneration(args: {
    .update('|')
    .update(String(TITLE_WRAPPER_VERSION))
    .update('|')
-    .update(getEmbeddingModelTag());
-  if (args.synopsisDocMaxChars !== undefined) {
-    h.update('|doc_cap=').update(String(args.synopsisDocMaxChars));
-  }
-  return h.digest('hex').slice(0, 16);
+    .update(getEmbeddingModelTag())
+    .digest('hex')
+    .slice(0, 16);
 }

 /**
@@ -265,11 +253,7 @@ export async function reembedPageWithContextualRetrieval(
      args.pageSlug,
      args.sourceId,
      resolution.mode,
-      computeCorpusGeneration({
-        crMode: resolution.mode,
-        haikuModel: args.haikuModel ?? DEFAULT_HAIKU_MODEL,
-        synopsisDocMaxChars: resolution.mode === 'per_chunk_synopsis' ? SYNOPSIS_DOC_MAX_CHARS : undefined,
-      }),
+      computeCorpusGeneration({ crMode: resolution.mode, haikuModel: args.haikuModel ?? DEFAULT_HAIKU_MODEL }),
    );
    return { kind: 'skipped', reason: 'no_chunks' };
  }
@@ -298,7 +282,6 @@ export async function reembedPageWithContextualRetrieval(
      const corpus_generation = computeCorpusGeneration({
        crMode: attemptMode,
        haikuModel,
-        synopsisDocMaxChars: attemptMode === 'per_chunk_synopsis' ? SYNOPSIS_DOC_MAX_CHARS : undefined,
      });

      // ── PHASE 2: single DB transaction ───────────────────────────
@@ -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),
  };
 }
@@ -733,11 +733,6 @@ export async function importFromContent(
      : computeCorpusGeneration({
          crMode: effectiveCRMode,
          haikuModel: 'anthropic:claude-haiku-4-5-20251001',
-          // Inline import-file path never uses per_chunk_synopsis (refuses
-          // upstream); pass undefined so the doc-cap field stays out of
-          // the hash here. Per_chunk_synopsis runs through the Minion
-          // backfill handler which threads SYNOPSIS_DOC_MAX_CHARS through
-          // the service layer.
        });

  // Transaction wraps all DB writes. Every per-page tx call carries the
@@ -489,22 +489,7 @@ export async function extractPageLinks(
      // text inside `[[...]]` before any `|`), NOT the display alias
      // (ref.name = match[2]). `[[struktura|the project]]` must resolve
      // `struktura`, not "the project". The display text is for context only.
-      //
-      // The literal may be path-qualified (`[[notes/struktura]]`). The FS
-      // path (resolveSlugAll) strips the dirname before its basename lookup,
-      // but this path passed the raw literal to an index keyed by final
-      // segments only — so every slash-containing wikilink outside
-      // DIR_PATTERN silently resolved to nothing. Query by the final
-      // segment, then use the written path as a disambiguation filter
-      // (the analogue of the FS ancestor walk honoring the written path):
-      // a match must end with the literal, so `[[notes/struktura]]` can
-      // resolve to `vault/notes/struktura` but never to `wiki/struktura`.
-      const slashIdx = ref.slug.lastIndexOf('/');
-      const basename = slashIdx === -1 ? ref.slug : ref.slug.slice(slashIdx + 1);
-      let matches = await resolver.resolveBasenameMatches(basename);
-      if (slashIdx !== -1) {
-        matches = matches.filter(m => m === ref.slug || m.endsWith(`/${ref.slug}`));
-      }
+      const matches = await resolver.resolveBasenameMatches(ref.slug);
      if (matches.length === 0) continue;
      const idx = content.indexOf(ref.slug);
      const context = idx >= 0 ? excerpt(content, idx, 240) : ref.name;
@@ -1,116 +0,0 @@
-/**
- * Shared orphan-reporting exclusion policy.
- *
- * These are pages where "no inbound links" is expected and should not count
- * against health. Keep this in core so the CLI orphan report and engine health
- * dashboard cannot drift.
- *
- * Defaults are GBrain-wide conventions only. Brain-specific exclusions
- * (private folder names, one-off fixture slugs) belong in the brain's own
- * config, not here:
- *
- *   gbrain config set orphans.exclude_prefixes "my-private-folder/,archive/"
- *   gbrain config set orphans.exclude_slugs "some-one-off-page"
- */
-
-const AUTO_SUFFIX_PATTERNS = ['/_index', '/log'];
-
-const PSEUDO_SLUGS = new Set(['_atlas', '_index', '_stats', '_orphans', '_scratch', 'claude']);
-
-const RAW_SEGMENT = '/raw/';
-
-const DENY_PREFIXES = [
-  'output/',
-  'dashboards/',
-  'scripts/',
-  'templates/',
-  '_templates/',
-  'openclaw/config/',
-  'extracts/',
-];
-
-const FIRST_SEGMENT_EXCLUSIONS = new Set([
-  'scratch',
-  'thoughts',
-  'catalog',
-  'entities',
-  'raw',
-  'atoms',
-  'skills',
-  'dreaming',
-  'daily',
-]);
-
-const ROOT_DATE_SLUG = /^\d{4}-\d{2}-\d{2}(?:-.+)?$/;
-
-function isAgentWorkspaceConvention(slug: string): boolean {
-  if (!slug.startsWith('agents/')) return false;
-  if (slug.includes('/memory/dreaming/')) return true;
-  return /^agents\/[^/]+\/(?:agents|identity|soul|tools|user|heartbeat|dreams|dormant)$/.test(slug);
-}
-
-/** Per-brain additions to the convention defaults (from config). */
-export interface OrphanPolicyOverrides {
-  excludePrefixes?: string[];
-  excludeSlugs?: string[];
-}
-
-/** Config keys for per-brain orphan exclusions (comma-separated values). */
-export const ORPHAN_EXCLUDE_PREFIXES_KEY = 'orphans.exclude_prefixes';
-export const ORPHAN_EXCLUDE_SLUGS_KEY = 'orphans.exclude_slugs';
-
-function parseList(value: string | null): string[] {
-  if (!value) return [];
-  return value.split(',').map(s => s.trim()).filter(Boolean);
-}
-
-/**
- * Load per-brain orphan exclusions from the brain config table. Callers with
- * an engine in hand (getHealth, `gbrain orphans`) pass the result as the
- * second argument to shouldExcludeFromOrphanReporting.
- */
-export async function loadOrphanPolicyOverrides(
-  engine: { getConfig(key: string): Promise<string | null> },
-): Promise<OrphanPolicyOverrides> {
-  const [prefixes, slugs] = await Promise.all([
-    engine.getConfig(ORPHAN_EXCLUDE_PREFIXES_KEY),
-    engine.getConfig(ORPHAN_EXCLUDE_SLUGS_KEY),
-  ]);
-  return { excludePrefixes: parseList(prefixes), excludeSlugs: parseList(slugs) };
-}
-
-export function shouldExcludeFromOrphanReporting(
-  slug: string,
-  overrides?: OrphanPolicyOverrides,
-): boolean {
-  if (PSEUDO_SLUGS.has(slug)) return true;
-
-  for (const suffix of AUTO_SUFFIX_PATTERNS) {
-    if (slug.endsWith(suffix)) return true;
-  }
-
-  if (slug.includes(RAW_SEGMENT)) return true;
-  if (slug.includes('/daily/')) return true;
-
-  for (const prefix of DENY_PREFIXES) {
-    if (slug.startsWith(prefix)) return true;
-  }
-
-  const firstSegment = slug.split('/')[0];
-  if (FIRST_SEGMENT_EXCLUSIONS.has(firstSegment)) return true;
-
-  if (ROOT_DATE_SLUG.test(slug)) return true;
-
-  if (slug.startsWith('_brain-')) return true;
-
-  if (isAgentWorkspaceConvention(slug)) return true;
-
-  if (overrides) {
-    if (overrides.excludeSlugs?.includes(slug)) return true;
-    for (const prefix of overrides.excludePrefixes ?? []) {
-      if (slug.startsWith(prefix)) return true;
-    }
-  }
-
-  return false;
-}
@@ -44,33 +44,6 @@ const HAIKU_MAX_TOKENS = 200;
 /** Default model when caller doesn't override. Resolves through the gateway. */
 const DEFAULT_SYNOPSIS_MODEL = 'anthropic:claude-haiku-4-5-20251001';

-/**
- * Hard cap on `documentText` length (chars) before send.
- *
- * 2026-05-25 fix wave: small local chat models (Gemma 4 E2B, Qwen3 4B) get
- * dramatically slower on long contexts even with 131K-token windows declared.
- * A 73K-char page synopsis on Gemma 4 E2B takes 60-120s, exceeding the
- * worker's default 30s `lockDuration` and tripping `lock-lost` errors.
- *
- * Truncate to a budget that fits a small model's effective throughput while
- * preserving enough document context for the synopsis to be useful. Truncates
- * the TAIL because the head (title, frontmatter, intro) carries the
- * document-level anchor the synopsis needs.
- *
- * Override per workload via `GBRAIN_SYNOPSIS_DOC_MAX_CHARS`. Default 32768
- * (~8K tokens at 4 chars/tok) keeps small-model synopsis under ~30s.
- * Anthropic Haiku is unaffected at this cap; bump higher when running
- * frontier models if you want richer document anchoring.
- */
-export const SYNOPSIS_DOC_MAX_CHARS = (() => {
-  const env = process.env.GBRAIN_SYNOPSIS_DOC_MAX_CHARS;
-  if (env && /^\d+$/.test(env)) {
-    const n = parseInt(env, 10);
-    if (n >= 512 && n <= 1_048_576) return n;
-  }
-  return 32768;
-})();
-
 /**
 * Synopsis prompt version. Folded into corpus_generation so prompt edits
 * invalidate prior embeddings via the v0.40.3.0 query_cache.page_generations
@@ -215,19 +188,11 @@ function buildUserPrompt(
  documentText: string,
  chunkText: string,
 ): string {
-  // Tail-truncate `documentText` to `SYNOPSIS_DOC_MAX_CHARS` so small local
-  // chat models don't stall on >100KB pages. Head preserved (title block,
-  // frontmatter, intro paragraphs carry the document-level anchor).
-  let trimmedDoc = documentText;
-  if (documentText.length > SYNOPSIS_DOC_MAX_CHARS) {
-    trimmedDoc = documentText.slice(0, SYNOPSIS_DOC_MAX_CHARS) +
-      `\n\n[... ${documentText.length - SYNOPSIS_DOC_MAX_CHARS} chars truncated for synopsis budget ...]`;
-  }
  return [
    `<page_title>${pageTitle}</page_title>`,
    '',
    '<full_document>',
-    trimmedDoc,
+    documentText,
    '</full_document>',
    '',
    '<chunk>',
@@ -57,8 +57,6 @@ import { finalizeLastSeen } from './chronicle/last-seen.ts';
 import { computeAnomaliesFromBuckets } from './cycle/anomaly.ts';
 import { resolveBoostMap, resolveHardExcludes } from './search/source-boost.ts';
 import { buildSourceFactorCase, buildHardExcludeClause, buildVisibilityClause, buildRecencyComponentSql, buildBestPerPagePoolCte, buildOrFallbackWebsearchQuery } from './search/sql-ranking.ts';
-import { shouldExcludeFromOrphanReporting, loadOrphanPolicyOverrides } from './orphan-policy.ts';
-import { LINK_EXTRACTOR_VERSION_TS } from './link-extraction.ts';
 import {
  normalizeEngineColumn,
  buildVectorCastFragment,
@@ -2324,10 +2322,6 @@ export class PGLiteEngine implements BrainEngine {
    // v0.40.3.0 D24 NULL→non-NULL race fix mirrors postgres-engine.ts. Two writers
    // racing on the same chunk previously raced last-write-wins; the fix lets the
    // fresher `embedded_at` win in the text-unchanged branch.
-    //
-    // Code-chunk metadata columns follow the same chunk_text-gated CASE pattern as `embedding`
-    // (#769). Re-chunk trusts EXCLUDED outright; pure re-embed COALESCEs so a caller carrying
-    // only embedding-shaped fields doesn't clobber metadata to NULL.
    await this.db.query(
      `INSERT INTO content_chunks ${cols} VALUES ${rowParts.join(', ')}
       ON CONFLICT (page_id, chunk_index) DO UPDATE SET
@@ -2351,14 +2345,14 @@ export class PGLiteEngine implements BrainEngine {
                THEN EXCLUDED.embedded_at
           ELSE content_chunks.embedded_at
         END,
-         language = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.language ELSE COALESCE(EXCLUDED.language, content_chunks.language) END,
-         symbol_name = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name ELSE COALESCE(EXCLUDED.symbol_name, content_chunks.symbol_name) END,
-         symbol_type = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_type ELSE COALESCE(EXCLUDED.symbol_type, content_chunks.symbol_type) END,
-         start_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.start_line ELSE COALESCE(EXCLUDED.start_line, content_chunks.start_line) END,
-         end_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.end_line ELSE COALESCE(EXCLUDED.end_line, content_chunks.end_line) END,
-         parent_symbol_path = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.parent_symbol_path ELSE COALESCE(EXCLUDED.parent_symbol_path, content_chunks.parent_symbol_path) END,
-         doc_comment = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.doc_comment ELSE COALESCE(EXCLUDED.doc_comment, content_chunks.doc_comment) END,
-         symbol_name_qualified = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name_qualified ELSE COALESCE(EXCLUDED.symbol_name_qualified, content_chunks.symbol_name_qualified) END,
+         language = EXCLUDED.language,
+         symbol_name = EXCLUDED.symbol_name,
+         symbol_type = EXCLUDED.symbol_type,
+         start_line = EXCLUDED.start_line,
+         end_line = EXCLUDED.end_line,
+         parent_symbol_path = EXCLUDED.parent_symbol_path,
+         doc_comment = EXCLUDED.doc_comment,
+         symbol_name_qualified = EXCLUDED.symbol_name_qualified,
         modality = EXCLUDED.modality,
         embedding_image = COALESCE(EXCLUDED.embedding_image, content_chunks.embedding_image)`,
      params
@@ -5213,10 +5207,15 @@ export class PGLiteEngine implements BrainEngine {
        (SELECT count(*) FROM pages) as page_count,
        (SELECT count(*) FROM content_chunks WHERE embedded_at IS NOT NULL)::float /
          GREATEST((SELECT count(*) FROM content_chunks), 1)::float as embed_coverage,
-        0 as stale_pages,
-        -- Bug 11 — orphan = islanded (no inbound AND no outbound). The raw
-        -- list is filtered in TS using the shared orphan-reporting policy.
-        0 as orphan_pages,
+        (SELECT count(*) FROM pages p
+         WHERE p.updated_at < (SELECT MAX(te.created_at) FROM timeline_entries te WHERE te.page_id = p.id)
+        ) as stale_pages,
+        -- Bug 11 — orphan = islanded (no inbound AND no outbound).
+        -- See BrainHealth.orphan_pages docstring; docs updated to match this.
+        (SELECT count(*) FROM pages p
+         WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
+           AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
+        ) as orphan_pages,
        (SELECT count(*) FROM links l
         WHERE NOT EXISTS (SELECT 1 FROM pages p WHERE p.id = l.to_page_id)
        ) as dead_links,
@@ -5241,20 +5240,10 @@ export class PGLiteEngine implements BrainEngine {
      LIMIT 5
    `);

-    const { rows: islandedRows } = await this.db.query(`
-      SELECT p.slug
-      FROM pages p
-      WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
-        AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
-    `);
-
    const r = h as Record<string, unknown>;
    const pageCount = Number(r.page_count);
    const embedCoverage = Number(r.embed_coverage);
-    const stalePages = await this.countStalePagesForExtraction({ versionTs: LINK_EXTRACTOR_VERSION_TS });
-    const orphanOverrides = await loadOrphanPolicyOverrides(this);
-    const orphanPages = (islandedRows as { slug: string }[])
-      .filter(row => !shouldExcludeFromOrphanReporting(row.slug, orphanOverrides)).length;
+    const orphanPages = Number(r.orphan_pages);
    const deadLinks = Number(r.dead_links);
    const linkCount = Number(r.link_count);
    const pagesWithTimeline = Number(r.pages_with_timeline);
@@ -5282,7 +5271,7 @@ export class PGLiteEngine implements BrainEngine {
    return {
      page_count: pageCount,
      embed_coverage: embedCoverage,
-      stale_pages: stalePages,
+      stale_pages: Number(r.stale_pages),
      orphan_pages: orphanPages,
      missing_embeddings: Number(r.missing_embeddings),
      brain_score: brainScore,
@@ -67,8 +67,6 @@ import { resolveBoostMap, resolveHardExcludes } from './search/source-boost.ts';
 import { buildSourceFactorCase, buildHardExcludeClause, buildVisibilityClause, buildRecencyComponentSql, buildBestPerPagePoolCte, buildOrFallbackWebsearchQuery } from './search/sql-ranking.ts';
 import { DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_DIMENSIONS } from './ai/defaults.ts';
 import { DELETE_BATCH_SIZE } from './engine-constants.ts';
-import { shouldExcludeFromOrphanReporting, loadOrphanPolicyOverrides } from './orphan-policy.ts';
-import { LINK_EXTRACTOR_VERSION_TS } from './link-extraction.ts';

 function escapeSqlStringLiteral(value: string): string {
  return value.replace(/'/g, "''");
@@ -2475,13 +2473,6 @@ export class PostgresEngine implements BrainEngine {
    //   - new is fresher (embedded_at > existing.embedded_at) → take new
    //   - otherwise → keep existing (slower writer with stale embedding loses)
    // Mirrored in pglite-engine.ts; pinned by test/e2e/concurrent-embed-race.test.ts.
-    //
-    // Code-chunk metadata columns (language / symbol_name / symbol_type / line range /
-    // parent_symbol_path / doc_comment / symbol_name_qualified) follow the SAME chunk_text-gated
-    // CASE pattern as `embedding` (#769). Re-chunk (chunk_text changed) trusts EXCLUDED outright;
-    // pure re-embed (chunk_text unchanged) COALESCEs so a caller that only carries embedding
-    // doesn't clobber metadata to NULL. Without this, every embed --stale pass nuked code-def's
-    // primary index for thousands of chunks at once.
    await sql.unsafe(
      `INSERT INTO content_chunks ${cols} VALUES ${rows.join(', ')}
       ON CONFLICT (page_id, chunk_index) DO UPDATE SET
@@ -2505,14 +2496,14 @@ export class PostgresEngine implements BrainEngine {
                THEN EXCLUDED.embedded_at
           ELSE content_chunks.embedded_at
         END,
-         language = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.language ELSE COALESCE(EXCLUDED.language, content_chunks.language) END,
-         symbol_name = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name ELSE COALESCE(EXCLUDED.symbol_name, content_chunks.symbol_name) END,
-         symbol_type = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_type ELSE COALESCE(EXCLUDED.symbol_type, content_chunks.symbol_type) END,
-         start_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.start_line ELSE COALESCE(EXCLUDED.start_line, content_chunks.start_line) END,
-         end_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.end_line ELSE COALESCE(EXCLUDED.end_line, content_chunks.end_line) END,
-         parent_symbol_path = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.parent_symbol_path ELSE COALESCE(EXCLUDED.parent_symbol_path, content_chunks.parent_symbol_path) END,
-         doc_comment = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.doc_comment ELSE COALESCE(EXCLUDED.doc_comment, content_chunks.doc_comment) END,
-         symbol_name_qualified = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name_qualified ELSE COALESCE(EXCLUDED.symbol_name_qualified, content_chunks.symbol_name_qualified) END,
+         language = EXCLUDED.language,
+         symbol_name = EXCLUDED.symbol_name,
+         symbol_type = EXCLUDED.symbol_type,
+         start_line = EXCLUDED.start_line,
+         end_line = EXCLUDED.end_line,
+         parent_symbol_path = EXCLUDED.parent_symbol_path,
+         doc_comment = EXCLUDED.doc_comment,
+         symbol_name_qualified = EXCLUDED.symbol_name_qualified,
         modality = EXCLUDED.modality,
         embedding_image = COALESCE(EXCLUDED.embedding_image, content_chunks.embedding_image)`,
      params as Parameters<typeof sql.unsafe>[1],
@@ -5322,9 +5313,11 @@ export class PostgresEngine implements BrainEngine {
  async getHealth(): Promise<BrainHealth> {
    const sql = this.sql;
    // Bug 11 doc-drift fix — orphan_pages means "islanded" (no inbound AND
-    // no outbound links). The raw islanded list is filtered through the same
-    // policy as `gbrain orphans` so convention pages do not count against
-    // dashboard health.
+    // no outbound links), aligning both engines with the user-facing
+    // definition. The type comment previously said "no inbound" but the
+    // SQL required both — docs now match code so users can trust the
+    // number. A hub page that links out to many but has no back-references
+    // is working as intended, not an orphan.
    const [h] = await sql`
      WITH entity_pages AS (
        SELECT id, slug FROM pages WHERE type IN ('person', 'company')
@@ -5333,8 +5326,13 @@ export class PostgresEngine implements BrainEngine {
        (SELECT count(*) FROM pages) as page_count,
        (SELECT count(*) FROM content_chunks WHERE embedded_at IS NOT NULL)::float /
          GREATEST((SELECT count(*) FROM content_chunks), 1)::float as embed_coverage,
-        0 as stale_pages,
-        0 as orphan_pages,
+        (SELECT count(*) FROM pages p
+         WHERE p.updated_at < (SELECT MAX(te.created_at) FROM timeline_entries te WHERE te.page_id = p.id)
+        ) as stale_pages,
+        (SELECT count(*) FROM pages p
+         WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
+           AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
+        ) as orphan_pages,
        (SELECT count(*) FROM links l
         WHERE NOT EXISTS (SELECT 1 FROM pages p WHERE p.id = l.to_page_id)
        ) as dead_links,
@@ -5358,18 +5356,9 @@ export class PostgresEngine implements BrainEngine {
      LIMIT 5
    `;

-    const islandedRows = await sql<{ slug: string }[]>`
-      SELECT p.slug
-      FROM pages p
-      WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
-        AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
-    `;
-
    const pageCount = Number(h.page_count);
    const embedCoverage = Number(h.embed_coverage);
-    const stalePages = await this.countStalePagesForExtraction({ versionTs: LINK_EXTRACTOR_VERSION_TS });
-    const orphanOverrides = await loadOrphanPolicyOverrides(this);
-    const orphanPages = islandedRows.filter(row => !shouldExcludeFromOrphanReporting(row.slug, orphanOverrides)).length;
+    const orphanPages = Number(h.orphan_pages);
    const deadLinks = Number(h.dead_links);
    const linkCount = Number(h.link_count);
    const pagesWithTimeline = Number(h.pages_with_timeline);
@@ -5397,7 +5386,7 @@ export class PostgresEngine implements BrainEngine {
    return {
      page_count: pageCount,
      embed_coverage: embedCoverage,
-      stale_pages: stalePages,
+      stale_pages: Number(h.stale_pages),
      orphan_pages: orphanPages,
      missing_embeddings: Number(h.missing_embeddings),
      brain_score: brainScore,
@@ -93,13 +93,7 @@ import { resolveLrSchedule } from './lr-schedule.ts';
 import { preflight, formatPreflightReport } from './preflight.ts';
 import { isRejected, loadRejectedBuffer, makeRejectedEntry, saveRejectedBuffer } from './rejected-buffer.ts';
 import { runReflect, runOneShotRewrite, describeJudges } from './reflect.ts';
-import {
-  acceptCandidate,
-  proposedPath as proposedFilePath,
-  revertAllPending,
-  skillPath,
-  writeProposed,
-} from './version-store.ts';
+import { acceptCandidate, bestPath, revertAllPending, skillPath, writeProposed } from './version-store.ts';
 import { runValidationGate, scoreSkillOnTasks } from './validate-gate.ts';
 import { ROLLOUT_SUCCESS_THRESHOLD } from './types.ts';
 import type { SkillOptOpts, EditOp, RunReceipt, BenchmarkTask } from './types.ts';
@@ -708,9 +702,9 @@ async function runOptimizationLoop(
  // to the catch's assignment values only (it can't prove the async callback ran).
  const finalOutcome = outcome as 'accepted' | 'no_improvement' | 'aborted' | 'errored';
  if (!mutateDecision.mutate && finalOutcome === 'accepted') {
-    // writeProposed() emitted both the best pointer and the stable review
-    // artifact in the accept branch. SKILL.md remains untouched.
-    proposedPath = proposedFilePath(skillsDir, skillName);
+    // best.md was written by writeProposed() in the accept branch (no-mutate
+    // path); it doubles as proposed.md for human review. SKILL.md untouched.
+    proposedPath = bestPath(skillsDir, skillName);
  } else if (mutateDecision.mutate) {
    mutatedSkillFile = finalOutcome === 'accepted';
  }
@@ -23,7 +23,6 @@
 *
 *   history.json
 *   best.md
- *   proposed.md
 *   versions/
 *     v0001_e1_s1.md
 *     v0002_e1_s2.md
@@ -53,10 +52,6 @@ export function bestPath(skillsDir: string, skillName: string): string {
  return path.join(skilloptDir(skillsDir, skillName), 'best.md');
 }

-export function proposedPath(skillsDir: string, skillName: string): string {
-  return path.join(skilloptDir(skillsDir, skillName), 'proposed.md');
-}
-
 export function skillPath(skillsDir: string, skillName: string): string {
  return path.join(skillsDir, skillName, 'SKILL.md');
 }
@@ -176,18 +171,17 @@ export function acceptCandidate(input: AcceptInput): AcceptResult {
 }

 /**
- * Write the candidate to both `best.md` and `proposed.md` WITHOUT touching
- * SKILL.md or the history ledger. `best.md` remains the optimizer's current
- * best pointer; `proposed.md` is the stable human-review artifact promised by
- * `--no-mutate`. Returns the proposal path. Each write is atomic (.tmp + rename).
+ * Write the candidate to `best.md` (which doubles as `proposed.md`) WITHOUT
+ * touching SKILL.md or the history ledger. Used by the `--no-mutate` /
+ * bundled-without-allow paths: the optimizer found a better candidate but the
+ * caller opted out of in-place mutation, so we surface it for human review.
+ * Returns the path written. Atomic (.tmp + rename).
 */
 export function writeProposed(skillsDir: string, skillName: string, candidateText: string): string {
-  const best = bestPath(skillsDir, skillName);
-  const proposed = proposedPath(skillsDir, skillName);
-  fs.mkdirSync(path.dirname(best), { recursive: true });
-  atomicWrite(best, candidateText);
-  atomicWrite(proposed, candidateText);
-  return proposed;
+  const p = bestPath(skillsDir, skillName);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  atomicWrite(p, candidateText);
+  return p;
 }

 /**
@@ -63,26 +63,25 @@ interface PluginCtx {
  [key: string]: unknown;
 }

-export function register(api: PluginApi) {
-  api.registerContextEngine(ENGINE_ID, (ctx: PluginCtx) => {
-    const hostResolver =
-      typeof ctx.resolveEntities === 'function'
-        ? ctx.resolveEntities
-        : typeof ctx.brainQuery === 'function'
-          ? ctx.brainQuery
-          : undefined;
-    return createGBrainContextEngine({
-      workspaceDir: ctx.workspaceDir,
-      resolveEntities: hostResolver,
-    });
-  });
-}
-
 const entry: PluginEntry = {
  id: 'gbrain-context-engine',
  name: 'GBrain Context Engine',
  description: 'Deterministic temporal/spatial context injection on every turn',
-  register,
+
+  register(api: PluginApi) {
+    api.registerContextEngine(ENGINE_ID, (ctx: PluginCtx) => {
+      const hostResolver =
+        typeof ctx.resolveEntities === 'function'
+          ? ctx.resolveEntities
+          : typeof ctx.brainQuery === 'function'
+            ? ctx.brainQuery
+            : undefined;
+      return createGBrainContextEngine({
+        workspaceDir: ctx.workspaceDir,
+        resolveEntities: hostResolver,
+      });
+    });
+  },
 };

 export default entry;
@@ -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');
+  });
+});
@@ -172,59 +172,6 @@ describe('issue #972 — DB-source (gbrain extract links --source db)', () => {
    expect(strk!.link_type).toBe('wikilink_basename');
  });

-  test('flag ON → path-qualified wikilink outside DIR_PATTERN resolves via DB path', async () => {
-    // `[[notes/struktura]]` — `notes` is not in DIR_PATTERN, so the ref
-    // reaches the generic pass with its dirname intact. Regression: the DB
-    // path queried the basename index with the raw literal (which is keyed
-    // by final segments only), so path-qualified wikilinks outside
-    // DIR_PATTERN silently produced zero edges while the FS path resolved
-    // the identical content.
-    await engine.putPage('notes/struktura', {
-      type: 'concept' as any, title: 'Struktura Notes',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('concepts/knowledge-graph', {
-      type: 'concept', title: 'Knowledge Graph',
-      compiled_truth: 'Background in [[notes/struktura]].', timeline: '',
-    });
-    await engine.setConfig('link_resolution.global_basename', 'true');
-
-    await runExtract(engine, ['links', '--source', 'db']);
-
-    const outLinks = await engine.getLinks('concepts/knowledge-graph');
-    const strk = outLinks.find(l => l.to_slug === 'notes/struktura');
-    expect(strk).toBeDefined();
-    expect(strk!.link_type).toBe('wikilink_basename');
-    expect(strk!.link_source).toBe('wikilink-resolved');
-  });
-
-  test('path-qualified wikilink never attaches to a basename-only sibling', async () => {
-    // Both notes/struktura and wiki/struktura exist. The author wrote
-    // `[[notes/struktura]]` — the written path must exclude wiki/struktura
-    // (a bare `[[struktura]]` would legitimately match both).
-    await engine.putPage('notes/struktura', {
-      type: 'concept' as any, title: 'Struktura Notes',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('wiki/struktura', {
-      type: 'concept' as any, title: 'Struktura Wiki',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('concepts/x', {
-      type: 'concept', title: 'X',
-      compiled_truth: 'See [[notes/struktura]].', timeline: '',
-    });
-    await engine.setConfig('link_resolution.global_basename', 'true');
-
-    await runExtract(engine, ['links', '--source', 'db']);
-
-    const outLinks = await engine.getLinks('concepts/x');
-    const basenameLinks = outLinks
-      .filter(l => l.link_type === 'wikilink_basename')
-      .map(l => l.to_slug);
-    expect(basenameLinks).toEqual(['notes/struktura']);
-  });
-
  test('flag OFF → no basename edges via DB path (back-compat)', async () => {
    await engine.putPage('projects/struktura', {
      type: 'project', title: 'Struktura',
@@ -39,7 +39,6 @@ import { runSkillOpt } from '../../src/core/skillopt/orchestrator.ts';
 import {
  bestPath,
  loadHistory,
-  proposedPath,
  skillPath,
 } from '../../src/core/skillopt/version-store.ts';
 import { loadRejectedBuffer } from '../../src/core/skillopt/rejected-buffer.ts';
@@ -742,7 +741,7 @@ describe('skillopt T3 — F11 held-out gate, ablation opts, no-DB-pollution', ()
    } finally { fixture.cleanup(); }
  });

-  test('--no-mutate writes proposed.md and best.md, leaves SKILL.md untouched', async () => {
+  test('--no-mutate writes proposed.md (best.md), leaves SKILL.md untouched', async () => {
    const fixture = setupFixture(SKILL_PEOPLE_ONLY, CITATIONS_BENCHMARK);
    try {
      installStub({
@@ -754,9 +753,10 @@ describe('skillopt T3 — F11 held-out gate, ablation opts, no-DB-pollution', ()
          const result = await runOnce(fixture, { noMutate: true });
          expect(result.outcome).toBe('accepted');
          expect(result.mutatedSkillFile).toBe(false);
-          expect(result.proposedPath).toBe(proposedPath(fixture.skillsDir, SKILL));
+          expect(result.proposedPath).toBeDefined();
+          // proposed.md (best.md) exists and carries the improvement.
+          expect(fs.existsSync(result.proposedPath!)).toBe(true);
          expect(fs.readFileSync(result.proposedPath!, 'utf8')).toContain('## Citations');
-          expect(fs.readFileSync(bestPath(fixture.skillsDir, SKILL), 'utf8')).toContain('## Citations');
          // SKILL.md on disk is UNCHANGED (still People-only).
          const skill = fs.readFileSync(skillPath(fixture.skillsDir, SKILL), 'utf8');
          expect(skill).not.toContain('## Citations');
@@ -803,107 +803,3 @@ describe('embedAllStale --source threading (D7)', () => {
    expect((firstCallOpts as { sourceId?: string }).sourceId).toBe('media-corpus');
  });
 });
-
-// ────────────────────────────────────────────────────────────────
-// Code metadata preservation across re-embed (regression for #769)
-// ────────────────────────────────────────────────────────────────
-//
-// gbrain v0.30.1 and earlier silently clobbered code-chunk metadata
-// (language, symbol_name, symbol_type, start_line, end_line,
-// parent_symbol_path, doc_comment, symbol_name_qualified) on every
-// re-embed pass. The chunker populated those columns at import time,
-// but embed.ts loaded chunks via getChunks then mapped them to a
-// stripped ChunkInput carrying only 5 fields. upsertChunks then
-// OVERWROTE (not COALESCEd) the metadata columns from EXCLUDED, so
-// re-embed wiped them to NULL. End result on a real brain: 4875 code
-// pages, 47866 chunks, all with NULL language/symbol_name/symbol_type;
-// code-def returned 0 hits across every indexed repo.
-//
-// All three runEmbed paths (--stale autopilot, --all, --slugs) must
-// thread metadata through the re-upsert. Tests below assert that the
-// engine.upsertChunks call carries the same metadata it loaded.
-
-describe('runEmbed preserves code-chunk metadata across re-embed (regression for #769)', () => {
-  const fullCodeChunk = {
-    chunk_index: 0,
-    chunk_text: '[Java] foo/Bar.java:10-20 method baz',
-    chunk_source: 'compiled_truth' as const,
-    embedded_at: null,
-    token_count: 12,
-    language: 'java',
-    symbol_name: 'baz',
-    symbol_type: 'function',
-    start_line: 10,
-    end_line: 20,
-    parent_symbol_path: ['Bar'],
-    doc_comment: 'does the thing',
-    symbol_name_qualified: 'Bar.baz',
-  };
-
-  function metadataOf(chunk: any) {
-    return {
-      language: chunk.language,
-      symbol_name: chunk.symbol_name,
-      symbol_type: chunk.symbol_type,
-      start_line: chunk.start_line,
-      end_line: chunk.end_line,
-      parent_symbol_path: chunk.parent_symbol_path,
-      doc_comment: chunk.doc_comment,
-      symbol_name_qualified: chunk.symbol_name_qualified,
-    };
-  }
-
-  test('--stale (autopilot path) carries code metadata into upsertChunks', async () => {
-    const stale = [{
-      slug: 'code-page',
-      chunk_index: 0,
-      chunk_text: fullCodeChunk.chunk_text,
-      chunk_source: 'compiled_truth',
-      model: null,
-      token_count: 12,
-    }];
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      countStaleChunks: async () => 1,
-      listStaleChunks: async () => stale,
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--stale']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-
-  test('--all (full re-embed) carries code metadata into upsertChunks', async () => {
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      listPages: async () => [{ slug: 'code-page' }],
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--all']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-
-  test('--slugs (per-page embed) carries code metadata into upsertChunks', async () => {
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      getPage: async () => ({ slug: 'code-page', compiled_truth: 'x', timeline: '' }),
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--slugs', 'code-page']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-});
@@ -403,77 +403,6 @@ describe('extractPageLinks', () => {
    expect(candidates).toEqual([]);
  });

-  test('path-qualified wikilink outside DIR_PATTERN queries by final segment', async () => {
-    // `[[notes/struktura]]` (dir not in DIR_PATTERN) falls to the generic
-    // pass. The resolver's basename index is keyed by final path segments,
-    // so the lookup must strip the dirname — mirroring the FS path
-    // (resolveSlugAll). Regression: the raw literal was passed through,
-    // which never matched, so these links silently dropped.
-    const seen: string[] = [];
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) => {
-        seen.push(name);
-        return name === 'struktura' ? ['notes/struktura'] : [];
-      },
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(seen).toContain('struktura');
-    expect(seen).not.toContain('notes/struktura');
-    expect(candidates.map(c => c.targetSlug)).toEqual(['notes/struktura']);
-    expect(candidates[0].linkType).toBe('wikilink_basename');
-    expect(candidates[0].linkSource).toBe('wikilink-resolved');
-  });
-
-  test('path-qualified wikilink keeps only matches ending with the written path', async () => {
-    // The written path disambiguates: `[[notes/struktura]]` must never
-    // attach to `wiki/struktura` even though both share the basename.
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['notes/struktura', 'wiki/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates.map(c => c.targetSlug)).toEqual(['notes/struktura']);
-  });
-
-  test('path-qualified wikilink matches a deeper real slug by path suffix', async () => {
-    // The page lives at vault/notes/struktura; the author wrote the shorter
-    // tail `[[notes/struktura]]`. Suffix matching connects them, while the
-    // basename-only sibling `wiki/struktura` stays excluded.
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['vault/notes/struktura', 'wiki/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates.map(c => c.targetSlug)).toEqual(['vault/notes/struktura']);
-  });
-
-  test('path-qualified self-link is dropped like the bare form', async () => {
-    // `[[notes/struktura]]` written on notes/struktura itself must not
-    // produce a self-loop (same guard as the bare `[[own-tail]]` case).
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['notes/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'notes/struktura', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates).toEqual([]);
-  });
-
  test('bare wikilink resolution does not interfere with DIR_PATTERN wikilinks', async () => {
    // 2b refs (people/alice) take the verb-inferred type;
    // 2c refs (struktura) take wikilink_basename. Same call.
@@ -1,62 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  extractCycleFreshnessSourceIds,
-  parseMaintainArgs,
-} from '../src/commands/maintain.ts';
-import type { Check } from '../src/commands/doctor.ts';
-
-describe('maintain args', () => {
-  test('defaults to dry-run unless --safe is explicit', () => {
-    expect(parseMaintainArgs([])).toMatchObject({
-      safe: false,
-      dryRun: true,
-      json: false,
-    });
-  });
-
-  test('--safe enables mutating safe mode', () => {
-    expect(parseMaintainArgs(['--safe', '--json'])).toMatchObject({
-      safe: true,
-      dryRun: false,
-      json: true,
-    });
-  });
-
-  test('--dry-run wins over --safe', () => {
-    expect(parseMaintainArgs(['--safe', '--dry-run'])).toMatchObject({
-      safe: true,
-      dryRun: true,
-    });
-  });
-});
-
-describe('cycle freshness source extraction', () => {
-  test('extracts stale source ids from doctor messages', () => {
-    const checks: Check[] = [
-      {
-        name: 'cycle_freshness',
-        status: 'fail',
-        message: "Source 'brain-sync-remote-teffur' last cycled 40h ago. Run `gbrain dream --source <id>`.",
-      },
-      {
-        name: 'cycle_freshness',
-        status: 'fail',
-        message: "Source 'wiki' last cycled 25h ago. Source 'wiki' last cycled 25h ago.",
-      },
-    ];
-
-    expect(extractCycleFreshnessSourceIds(checks)).toEqual([
-      'brain-sync-remote-teffur',
-      'wiki',
-    ]);
-  });
-
-  test('ignores ok and unrelated checks', () => {
-    const checks: Check[] = [
-      { name: 'cycle_freshness', status: 'ok', message: "Source 'fresh' last cycled recently." },
-      { name: 'frontmatter_integrity', status: 'warn', message: "Source 'wiki' has frontmatter issues." },
-    ];
-
-    expect(extractCycleFreshnessSourceIds(checks)).toEqual([]);
-  });
-});
@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-describe('root OpenClaw plugin manifest', () => {
-  it('declares the id required by OpenClaw plugin installs', () => {
-    const manifest = JSON.parse(readFileSync(join(import.meta.dir, '..', 'openclaw.plugin.json'), 'utf8'));
-    const entrySource = readFileSync(join(import.meta.dir, '..', 'src', 'openclaw-context-engine.ts'), 'utf8');
-    const entryId = entrySource.match(/id:\s*'([^']+)'/)?.[1];
-
-    expect(manifest.id).toBe(entryId);
-    expect(manifest.configSchema).toBeDefined();
-    expect(typeof manifest.configSchema).toBe('object');
-    expect(manifest.contracts?.contextEngines).toContain('gbrain-context');
-    expect(entrySource).toContain('export function register');
-  });
-});
@@ -186,67 +186,11 @@ describe('shouldExclude — orphan filter regression (preserve curation)', () =>
    expect(shouldExclude('entities/anonymous')).toBe(true);
    expect(shouldExclude('atoms/fact-123')).toBe(true);
    expect(shouldExclude('skills/gbrain-operations')).toBe(true);
-    expect(shouldExclude('dreaming/light/2026-07-20')).toBe(true);
-    expect(shouldExclude('daily/2026-07-20')).toBe(true);
-    expect(shouldExclude('agent-openclaw/daily/2026-07-20')).toBe(true);
-  });
-
-  test('workspace convention slugs are excluded', () => {
-    expect(shouldExclude('_brain-conventions')).toBe(true);
-    expect(shouldExclude('_templates/decision')).toBe(true);
-    expect(shouldExclude('extracts/2026-06-30/takes.proposed/round-single')).toBe(true);
-    expect(shouldExclude('2026-07-20')).toBe(true);
-    expect(shouldExclude('2026-07-20-qa-sweep')).toBe(true);
-    expect(shouldExclude('agents/arya/identity')).toBe(true);
-    expect(shouldExclude('agents/arya/memory/dreaming/deep/2026-07-20')).toBe(true);
  });

  test('regular slugs are NOT excluded', () => {
    expect(shouldExclude('people/alice')).toBe(false);
    expect(shouldExclude('companies/acme')).toBe(false);
    expect(shouldExclude('writing/post-1')).toBe(false);
-    expect(shouldExclude('agents/arya/qa-reports/launch-review')).toBe(false);
-  });
-});
-
-describe('getHealth orphan_pages uses shared exclusion policy', () => {
-  test('excluded convention islands do not count against health', async () => {
-    await engine.putPage('_templates/decision', {
-      type: 'template', title: 'Decision', compiled_truth: 'template', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('skills/arya/source-check', {
-      type: 'concept', title: 'Skill', compiled_truth: 'skill', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('agents/arya/identity', {
-      type: 'note', title: 'Identity', compiled_truth: 'identity', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('people/alice', {
-      type: 'person', title: 'Alice', compiled_truth: 'real island', timeline: '', frontmatter: {},
-    });
-
-    const health = await engine.getHealth();
-
-    expect(health.orphan_pages).toBe(1);
-  });
-
-  test('per-brain config overrides (orphans.exclude_*) also apply to health', async () => {
-    await engine.putPage('my-private-folder/secret-ref', {
-      type: 'note', title: 'Ref', compiled_truth: 'ref', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('one-off-fixture-page', {
-      type: 'note', title: 'Fixture', compiled_truth: 'fixture', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('people/alice', {
-      type: 'person', title: 'Alice', compiled_truth: 'real island', timeline: '', frontmatter: {},
-    });
-
-    expect((await engine.getHealth()).orphan_pages).toBe(3);
-
-    await engine.setConfig('orphans.exclude_prefixes', 'my-private-folder/');
-    await engine.setConfig('orphans.exclude_slugs', 'one-off-fixture-page');
-    expect((await engine.getHealth()).orphan_pages).toBe(1);
-
-    await engine.unsetConfig('orphans.exclude_prefixes');
-    await engine.unsetConfig('orphans.exclude_slugs');
  });
 });
@@ -66,10 +66,6 @@ describe('shouldExclude', () => {
    expect(shouldExclude('templates/meeting-note')).toBe(true);
  });

-  test('excludes deny-prefix: _templates/', () => {
-    expect(shouldExclude('_templates/meeting-note')).toBe(true);
-  });
-
  test('excludes deny-prefix: openclaw/config/', () => {
    expect(shouldExclude('openclaw/config/agent')).toBe(true);
  });
@@ -90,44 +86,10 @@ describe('shouldExclude', () => {
    expect(shouldExclude('entities/product-hunt')).toBe(true);
  });

-  test('excludes first-segment: skills, dreaming, and daily', () => {
-    expect(shouldExclude('skills/arya/source-check')).toBe(true);
-    expect(shouldExclude('dreaming/light/2026-07-20')).toBe(true);
-    expect(shouldExclude('daily/2026-07-20')).toBe(true);
-    expect(shouldExclude('agent-openclaw/daily/2026-07-20')).toBe(true);
-  });
-
-  test('excludes root date logs and agent workspace conventions', () => {
-    expect(shouldExclude('_brain-conventions')).toBe(true);
-    expect(shouldExclude('2026-07-20')).toBe(true);
-    expect(shouldExclude('2026-07-20-qa-sweep')).toBe(true);
-    expect(shouldExclude('agents/arya/identity')).toBe(true);
-    expect(shouldExclude('agents/arya/memory/dreaming/deep/2026-07-20')).toBe(true);
-  });
-
-  test('excludes generated extracts', () => {
-    expect(shouldExclude('extracts/2026-06-30/takes.proposed/round-single')).toBe(true);
-  });
-
-  test('brain-specific exclusions come from config overrides, not global defaults', () => {
-    // No baked-in defaults for these:
-    expect(shouldExclude('my-private-folder/some-secret-ref.md')).toBe(false);
-    expect(shouldExclude('one-off-fixture-page')).toBe(false);
-    // The per-brain config plane (orphans.exclude_prefixes / exclude_slugs):
-    const overrides = {
-      excludePrefixes: ['my-private-folder/'],
-      excludeSlugs: ['one-off-fixture-page'],
-    };
-    expect(shouldExclude('my-private-folder/some-secret-ref.md', overrides)).toBe(true);
-    expect(shouldExclude('one-off-fixture-page', overrides)).toBe(true);
-    expect(shouldExclude('people/jane-doe', overrides)).toBe(false);
-  });
-
  test('does NOT exclude a normal content page', () => {
    expect(shouldExclude('companies/acme')).toBe(false);
    expect(shouldExclude('people/jane-doe')).toBe(false);
    expect(shouldExclude('projects/gbrain')).toBe(false);
-    expect(shouldExclude('agents/arya/qa-reports/launch-review')).toBe(false);
  });

  test('does NOT exclude a page ending with log-like text that is not /log', () => {
@@ -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 () => {
@@ -27,24 +27,9 @@ import {
 } from '../../src/core/ai/gateway.ts';
 import type { PageInput, SearchOpts } from '../../src/core/types.ts';
 import type { RerankInput, RerankResult } from '../../src/core/ai/gateway.ts';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';

 let engine: PGLiteEngine;

-// These tests stub the gateway at 1536 dims (DIMS). Since v0.36.3.0 hybridSearch
-// resolves the embedding column via loadConfig(), whose precedence is
-// cfg.embedding_dimensions > gateway dims > default — so a contributor's real
-// ~/.gbrain/config.json (e.g. text-embedding-3-small at 1280) outranks the stub,
-// the 1536-d stub vector then fails the gateway dim check, search silently falls
-// back to keyword-only, and the reranker never runs (0 docs → 4 tests fail). CI
-// is green only because a fresh runner has no config file (#1527). Isolate
-// GBRAIN_HOME to an empty tmpdir so loadConfig() returns null and the stub's dims
-// win — same idiom as emptyHome() in test/ai/gateway-probe-chat-model.test.ts.
-let prevGbrainHome: string | undefined;
-let isolatedHome: string;
-
 const DIMS = 1536; // gateway default embedding dim
 const FAKE_EMB = Array.from({ length: DIMS }, (_, j) => (j === 0 ? 1 : 0.01));

@@ -55,12 +40,6 @@ function stubEmbeddings(): void {
 }

 beforeAll(async () => {
-  // Hermetic config home: ignore the machine's real ~/.gbrain so its
-  // embedding_dimensions can't outrank the 1536-d stub (see note above, #1527).
-  prevGbrainHome = process.env.GBRAIN_HOME;
-  isolatedHome = mkdtempSync(join(tmpdir(), 'gbrain-rerank-home-'));
-  process.env.GBRAIN_HOME = isolatedHome;
-
  engine = new PGLiteEngine();
  await engine.connect({});
  await engine.initSchema();
@@ -106,9 +85,6 @@ afterAll(async () => {
  __setEmbedTransportForTests(null);
  resetGateway();
  await engine.disconnect();
-  if (prevGbrainHome === undefined) delete process.env.GBRAIN_HOME;
-  else process.env.GBRAIN_HOME = prevGbrainHome;
-  rmSync(isolatedHome, { recursive: true, force: true });
 });

 describe('hybridSearch — reranker disabled (pass-through)', () => {
@@ -12,11 +12,9 @@ import {
  bestPath,
  historyPath,
  loadHistory,
-  proposedPath,
  revertAllPending,
  skillPath,
  versionsDir,
-  writeProposed,
 } from '../../src/core/skillopt/version-store.ts';

 let tmpDir: string;
@@ -81,19 +79,6 @@ describe('acceptCandidate (D8 two-phase commit)', () => {
  });
 });

-describe('writeProposed', () => {
-  test('writes distinct best and proposed artifacts without mutating SKILL.md (#2635)', () => {
-    const candidate = '---\nname: test\n---\nproposed body\n';
-
-    const written = writeProposed(tmpDir, SKILL, candidate);
-
-    expect(written).toBe(proposedPath(tmpDir, SKILL));
-    expect(fs.readFileSync(bestPath(tmpDir, SKILL), 'utf8')).toBe(candidate);
-    expect(fs.readFileSync(proposedPath(tmpDir, SKILL), 'utf8')).toBe(candidate);
-    expect(fs.readFileSync(skillPath(tmpDir, SKILL), 'utf8')).toContain('baseline body');
-  });
-});
-
 describe('revertAllPending (D8 crash recovery)', () => {
  test('no-op when no pending rows', () => {
    const reverted = revertAllPending(tmpDir, SKILL);