fix(skillopt): emit proposed.md in no-mutate mode (#2635)

writeProposed now writes both best.md (optimizer's current-best pointer)
and proposed.md (the stable review artifact documented by --no-mutate);
the orchestrator returns the real proposed.md path instead of aliasing
best.md. Fix lands in the shared helper so both accept-branch call sites
are covered.

Takeover of #2719.

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

docs/tutorials/improving-skills-with-skillopt.md

@@ -233,13 +233,14 @@ 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/best.md` instead, so an optimization pass can never
-silently mutate a skill other people depend on. Two ways to handle that:
+`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:
 
 ```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/best.md (the proposed rewrite), prints its path. Copy what you want.
+# → writes skills/meeting-prep/skillopt/proposed.md, updates best.md, and prints the proposal path.
 
 # Actually rewrite a bundled skill (explicit opt-in + an independent held-out set):
 gbrain skillopt brain-ops --split 1:1:1 --allow-mutate-bundled \

src/cli.ts

@@ -935,10 +935,7 @@ export function formatResult(opName: string, result: unknown): string {
         lines.push(`Link coverage (entities): ${(h.link_coverage * 100).toFixed(1)}%`);
       }
       if (h.timeline_coverage !== undefined) {
-        lines.push(`Timeline coverage (entity pages): ${(h.timeline_coverage * 100).toFixed(1)}%`);
-      }
-      if (h.timeline_coverage_score !== undefined) {
-        lines.push(`Timeline density (all pages): ${h.timeline_coverage_score}/15 (whole-brain brain-score component)`);
+        lines.push(`Timeline coverage (entities): ${(h.timeline_coverage * 100).toFixed(1)}%`);
       }
       if (Array.isArray(h.most_connected) && h.most_connected.length > 0) {
         lines.push('Most connected entities:');

src/commands/doctor.ts

@@ -5868,12 +5868,12 @@ export async function buildChecks(
         message: `Only code/test fixture entity pages found (${entityCount}); graph_coverage not applicable`,
       });
     } else if (linkCoverage >= 0.5 && timelineCoverage >= 0.5) {
-      checks.push({ name: 'graph_coverage', status: 'ok', message: `Entity link coverage ${linkPct}%, entity timeline coverage ${timelinePct}%` });
+      checks.push({ name: 'graph_coverage', status: 'ok', message: `Entity link coverage ${linkPct}%, timeline ${timelinePct}%` });
     } else {
       checks.push({
         name: 'graph_coverage',
         status: 'warn',
-        message: `Entity link coverage ${linkPct}%, entity timeline coverage ${timelinePct}% (${eligibleEntityCount} entity pages). Run: gbrain extract all`,
+        message: `Entity link coverage ${linkPct}%, timeline ${timelinePct}% (${eligibleEntityCount} entity pages). Run: gbrain extract all`,
       });
     }
 
@@ -5885,7 +5885,7 @@ export async function buildChecks(
       const parts = [
         `embed ${health.embed_coverage_score}/35`,
         `links ${health.link_density_score}/25`,
-        `timeline density (all pages) ${health.timeline_coverage_score}/15`,
+        `timeline ${health.timeline_coverage_score}/15`,
         `orphans ${health.no_orphans_score}/15`,
         `dead-links ${health.no_dead_links_score}/10`,
       ];

src/core/skillopt/orchestrator.ts

@@ -93,7 +93,13 @@ 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, bestPath, revertAllPending, skillPath, writeProposed } from './version-store.ts';
+import {
+  acceptCandidate,
+  proposedPath as proposedFilePath,
+  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';
@@ -702,9 +708,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') {
-    // 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);
+    // writeProposed() emitted both the best pointer and the stable review
+    // artifact in the accept branch. SKILL.md remains untouched.
+    proposedPath = proposedFilePath(skillsDir, skillName);
   } else if (mutateDecision.mutate) {
     mutatedSkillFile = finalOutcome === 'accepted';
   }

src/core/skillopt/version-store.ts

@@ -23,6 +23,7 @@
  *
  *   history.json
  *   best.md
+ *   proposed.md
  *   versions/
  *     v0001_e1_s1.md
  *     v0002_e1_s2.md
@@ -52,6 +53,10 @@ 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');
 }
@@ -171,17 +176,18 @@ export function acceptCandidate(input: AcceptInput): AcceptResult {
 }
 
 /**
- * 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).
+ * 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).
  */
 export function writeProposed(skillsDir: string, skillName: string, candidateText: string): string {
-  const p = bestPath(skillsDir, skillName);
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  atomicWrite(p, candidateText);
-  return p;
+  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;
 }
 
 /**

test/doctor-timeline-metric-labels-2298.test.ts

@@ -1,155 +0,0 @@
-/**
- * Issue #2298 — timeline metric presentation contract.
- *
- * Authoritative upstream semantics (src/core/types.ts):
- *   - Metric A `timeline_coverage` (entity-scoped, fraction 0–1):
- *       eligible entity pages WITH a timeline entry / eligible entity pages
- *     -> surfaced by `graph_coverage` check AND `get_health` CLI entity line.
- *   - Metric B `timeline_coverage_score` (whole-brain, 0–15 brain-score component):
- *       all pages WITH a timeline entry / all pages
- *     -> surfaced by `brain_score` component breakdown AND (separately) CLI.
- *
- * The two have DIFFERENT numerators/denominators. This PR labels each
- * explicitly and keeps BOTH the entity CLI line and the whole-brain line.
- *
- * Tests (no private EriadorMu data, no production/home DB, no network):
- *   - numeric denominator assertions (Metric A = 50%, Metric B = 4/15)
- *   - doctor rendered-message assertions (exact labels, no ambiguous old label)
- *   - CLI rendered-output assertions (exact lines, guard matrix)
- *   - red/green: same assertions FAIL on origin/master, PASS on this branch
- *
- * Scoring formula UNCHANGED. Canonical PGLite fixture via resetPgliteState.
- */
-
-import { describe, expect, test, beforeAll, afterAll, beforeEach } from 'bun:test';
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-import { sqlQueryForEngine } from '../src/core/sql-query.ts';
-import { resetPgliteState } from './helpers/reset-pglite.ts';
-import { buildChecks } from '../src/commands/doctor.ts';
-import { formatResult } from '../src/cli.ts';
-
-let engine: PGLiteEngine;
-
-async function seedFourPages(eng: PGLiteEngine): Promise<void> {
-  const sql = sqlQueryForEngine(eng);
-  // 2 eligible entity pages, 2 technical/non-entity pages.
-  // Only ONE entity page has a timeline entry; only ONE total page does.
-  await sql`
-    INSERT INTO pages (slug, source_id, type, title, compiled_truth, frontmatter, content_hash, created_at, updated_at)
-    VALUES
-      ('acme-example', 'default', 'company', 'Acme', '', '{}', 'h1', now(), now()),
-      ('alice-example', 'default', 'person', 'Alice', '', '{}', 'h2', now(), now()),
-      ('technical-a', 'default', 'note', 'Tech A', '', '{}', 'h3', now(), now()),
-      ('technical-b', 'default', 'note', 'Tech B', '', '{}', 'h4', now(), now())
-  `;
-  const companyId = (await sql`SELECT id FROM pages WHERE slug='acme-example'`)[0].id as number;
-  await sql`INSERT INTO timeline_entries (page_id, date, source, summary, detail)
-    VALUES (${companyId}, CURRENT_DATE, 'test', 'milestone', '{}')`;
-}
-
-beforeAll(async () => {
-  engine = new PGLiteEngine();
-  await engine.connect({});
-  await engine.initSchema();
-});
-
-afterAll(async () => {
-  await engine.disconnect();
-});
-
-beforeEach(async () => {
-  await resetPgliteState(engine);
-});
-
-describe('issue #2298 — numeric denominator semantics', () => {
-  test('entity timeline coverage = 1/2 = 50% (2 eligible entities, 1 with timeline)', async () => {
-    await seedFourPages(engine);
-    const health = await engine.getHealth();
-    expect(health.timeline_coverage).toBeDefined();
-    expect(Math.round((health.timeline_coverage ?? 0) * 100)).toBe(50);
-  });
-
-  test('whole-brain timeline density = 1/4 -> score 4/15 (4 total pages, 1 with timeline)', async () => {
-    await seedFourPages(engine);
-    const health = await engine.getHealth();
-    expect(health.timeline_coverage_score).toBeDefined();
-    expect(health.timeline_coverage_score).toBe(4);
-  });
-
-  test('the two metrics use independent denominators', async () => {
-    await seedFourPages(engine);
-    const health = await engine.getHealth();
-    expect(Math.round((health.timeline_coverage ?? 0) * 100)).toBe(50);
-    expect(health.timeline_coverage_score ?? 0).toBe(4);
-    // 50% (entity, /2) != 26.7% (whole-brain, /4). Provably distinct.
-    expect(Math.round(((health.timeline_coverage_score ?? 0) / 15) * 100)).not.toBe(50);
-  });
-});
-
-describe('issue #2298 — doctor rendered-message contract', () => {
-  test('graph_coverage renders entity-scoped label with 50%', async () => {
-    await seedFourPages(engine);
-    const checks = await buildChecks(engine, [], null);
-    const graph = checks.find((c) => c.name === 'graph_coverage');
-    expect(graph, 'graph_coverage check must be present').toBeDefined();
-    expect(graph!.message).toContain('entity timeline coverage 50%');
-    // ambiguous old label must NOT be present
-    expect(graph!.message).not.toMatch(/timeline 50%/);
-    expect(graph!.message).not.toMatch(/timeline \(entity, brain score\)/);
-  });
-
-  test('brain_score renders whole-brain density label 4/15', async () => {
-    await seedFourPages(engine);
-    const checks = await buildChecks(engine, [], null);
-    const brain = checks.find((c) => c.name === 'brain_score');
-    expect(brain, 'brain_score check must be present').toBeDefined();
-    expect(brain!.message).toContain('timeline density (all pages) 4/15');
-    // wrong labels must NOT be present
-    expect(brain!.message).not.toMatch(/timeline 4\/15/);
-    expect(brain!.message).not.toMatch(/timeline \(entity, brain score\)/);
-    // brain-score component must NOT carry the word "entity" (it is whole-brain)
-    const timelinePart = brain!.message.split('timeline density (all pages) 4/15')[0] + 'timeline density (all pages) 4/15';
-    expect(timelinePart).not.toMatch(/entity/);
-  });
-});
-
-describe('issue #2298 — CLI get_health rendered-output contract', () => {
-  function fakeHealth(overrides: Record<string, unknown>): any {
-    return {
-      embed_coverage: 1, missing_embeddings: 0, stale_pages: 0, orphan_pages: 0,
-      link_coverage: 1, timeline_coverage: 0.5, timeline_coverage_score: 4,
-      most_connected: [], ...overrides,
-    };
-  }
-
-  test('both entity and whole-brain lines render, no undefined/15', () => {
-    const out = formatResult('get_health', fakeHealth({}));
-    expect(out).toContain('Timeline coverage (entity pages): 50.0%');
-    expect(out).toContain('Timeline density (all pages): 4/15');
-    expect(out).not.toContain('undefined/15');
-    expect(out).not.toContain('Timeline coverage (entities)');
-    expect(out).not.toMatch(/timeline \(entity, brain score\)/);
-    expect(out).not.toMatch(/bare "timeline 4\/15"/);
-  });
-
-  test('guard matrix: entity present, whole-brain absent -> only entity line', () => {
-    const out = formatResult('get_health', fakeHealth({ timeline_coverage_score: undefined }));
-    expect(out).toContain('Timeline coverage (entity pages): 50.0%');
-    expect(out).not.toContain('Timeline density (all pages)');
-    expect(out).not.toContain('undefined/15');
-  });
-
-  test('guard matrix: whole-brain present, entity absent -> only whole-brain line', () => {
-    const out = formatResult('get_health', fakeHealth({ timeline_coverage: undefined }));
-    expect(out).toContain('Timeline density (all pages): 4/15');
-    expect(out).not.toContain('Timeline coverage (entity pages)');
-    expect(out).not.toContain('undefined/15');
-  });
-
-  test('guard matrix: both absent -> neither timeline line, never undefined/15', () => {
-    const out = formatResult('get_health', fakeHealth({ timeline_coverage: undefined, timeline_coverage_score: undefined }));
-    expect(out).not.toContain('Timeline coverage (entity pages)');
-    expect(out).not.toContain('Timeline density (all pages)');
-    expect(out).not.toContain('undefined/15');
-  });
-});

test/e2e/skillopt-loop.serial.test.ts

@@ -39,6 +39,7 @@ 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';
@@ -741,7 +742,7 @@ describe('skillopt T3 — F11 held-out gate, ablation opts, no-DB-pollution', ()
     } finally { fixture.cleanup(); }
   });
 
-  test('--no-mutate writes proposed.md (best.md), leaves SKILL.md untouched', async () => {
+  test('--no-mutate writes proposed.md and best.md, leaves SKILL.md untouched', async () => {
     const fixture = setupFixture(SKILL_PEOPLE_ONLY, CITATIONS_BENCHMARK);
     try {
       installStub({
@@ -753,10 +754,9 @@ 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).toBeDefined();
-          // proposed.md (best.md) exists and carries the improvement.
-          expect(fs.existsSync(result.proposedPath!)).toBe(true);
+          expect(result.proposedPath).toBe(proposedPath(fixture.skillsDir, SKILL));
           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');

test/skillopt/version-store.test.ts

@@ -12,9 +12,11 @@ import {
   bestPath,
   historyPath,
   loadHistory,
+  proposedPath,
   revertAllPending,
   skillPath,
   versionsDir,
+  writeProposed,
 } from '../../src/core/skillopt/version-store.ts';
 
 let tmpDir: string;
@@ -79,6 +81,19 @@ 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);