gsd-pi 2.10.12 → 2.12.0

package/dist/resources/extensions/gsd/tests/activity-log-save.test.ts

@@ -0,0 +1,127 @@
+// Tests for saveActivityLog performance behavior:
+// - cache next sequence per activity directory instead of rescanning every save
+// - skip rewriting identical snapshots for the same unit
+// - recover safely if another writer creates the cached next sequence
+
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { saveActivityLog } from "../activity-log.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+let tmpDirs: string[] = [];
+
+function createBaseDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-activity-save-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+function activityDir(baseDir: string): string {
+  return join(baseDir, ".gsd", "activity");
+}
+
+function listActivityFiles(baseDir: string): string[] {
+  const dir = activityDir(baseDir);
+  return existsSync(dir) ? readdirSync(dir).sort() : [];
+}
+
+function createCtx(entries: unknown[]) {
+  return {
+    sessionManager: {
+      getEntries: () => entries,
+    },
+  };
+}
+
+function cleanup(): void {
+  for (const dir of tmpDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  tmpDirs = [];
+}
+
+process.on("exit", cleanup);
+
+async function main(): Promise<void> {
+  console.log("\n── (a) cache next sequence instead of rescanning every save");
+  {
+    const baseDir = createBaseDir();
+    saveActivityLog(createCtx([{ kind: "first", n: 1 }]) as any, baseDir, "execute-task", "M001/S01/T01");
+
+    writeFileSync(
+      join(activityDir(baseDir), "999-external-manual.jsonl"),
+      '{"external":true}\n',
+      "utf-8",
+    );
+
+    saveActivityLog(createCtx([{ kind: "second", n: 2 }]) as any, baseDir, "execute-task", "M001/S01/T02");
+
+    const files = listActivityFiles(baseDir);
+    assertTrue(files.includes("001-execute-task-M001-S01-T01.jsonl"), "(a) first save uses sequence 001");
+    assertTrue(files.includes("002-execute-task-M001-S01-T02.jsonl"), "(a) second save uses cached next sequence 002");
+    assertTrue(files.includes("999-external-manual.jsonl"), "(a) externally added file remains present");
+    assertTrue(!files.some(file => file.startsWith("1000-")), "(a) second save did not rescan and jump to sequence 1000");
+  }
+
+  console.log("\n── (b) skip rewriting identical snapshots for the same unit");
+  {
+    const baseDir = createBaseDir();
+    const ctx = createCtx([{ role: "assistant", content: "same snapshot" }]);
+
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+
+    let files = listActivityFiles(baseDir);
+    assertEq(files.length, 1, "(b) identical repeated save writes only one activity file");
+    assertTrue(files[0] === "001-plan-slice-M002-S01.jsonl", "(b) the original sequence is preserved");
+
+    saveActivityLog(createCtx([{ role: "assistant", content: "changed snapshot" }]) as any, baseDir, "plan-slice", "M002/S01");
+    files = listActivityFiles(baseDir);
+    assertEq(files.length, 2, "(b) changed snapshot writes a new activity file");
+    assertTrue(files.includes("002-plan-slice-M002-S01.jsonl"), "(b) deduped save did not consume the next sequence");
+  }
+
+  console.log("\n── (c) recover if another writer creates the exact cached target file");
+  {
+    const baseDir = createBaseDir();
+    saveActivityLog(createCtx([{ turn: 1 }]) as any, baseDir, "execute-task", "M003/S02/T01");
+
+    writeFileSync(
+      join(activityDir(baseDir), "002-execute-task-M003-S02-T02.jsonl"),
+      '{"collision":true}\n',
+      "utf-8",
+    );
+
+    saveActivityLog(createCtx([{ turn: 2 }]) as any, baseDir, "execute-task", "M003/S02/T02");
+
+    const files = listActivityFiles(baseDir);
+    assertTrue(files.includes("002-execute-task-M003-S02-T02.jsonl"), "(c) exact collision file is preserved");
+    assertTrue(files.includes("003-execute-task-M003-S02-T02.jsonl"), "(c) logger rescans only on collision and advances to 003");
+  }
+
+  console.log("\n── (d) dedupe is tracked per unit, not just the last write in the directory");
+  {
+    const baseDir = createBaseDir();
+    const repeatedCtx = createCtx([{ role: "assistant", content: "same-for-unit-a" }]);
+
+    saveActivityLog(repeatedCtx as any, baseDir, "execute-task", "M004/S01/T01");
+    saveActivityLog(createCtx([{ role: "assistant", content: "other-unit" }]) as any, baseDir, "execute-task", "M004/S01/T02");
+    saveActivityLog(repeatedCtx as any, baseDir, "execute-task", "M004/S01/T01");
+
+    const files = listActivityFiles(baseDir);
+    assertEq(files.length, 2, "(d) interleaving another unit does not force a duplicate rewrite for unit A");
+    assertTrue(files.includes("001-execute-task-M004-S01-T01.jsonl"), "(d) original unit A snapshot is retained");
+    assertTrue(files.includes("002-execute-task-M004-S01-T02.jsonl"), "(d) unit B snapshot is retained");
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/resources/extensions/gsd/tests/auto-draft-pause.test.ts

@@ -0,0 +1,109 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { describeNextUnit } from "../auto.js";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+// ─── Test describeNextUnit with 'needs-discussion' phase ──────────────────
+
+const ndState = {
+  phase: "needs-discussion" as const,
+  activeMilestone: { id: "M007", title: "Future Milestone" },
+  activeSlice: undefined,
+  activeTask: undefined,
+  milestoneRegistry: [],
+  nextAction: "",
+};
+
+const ndResult = describeNextUnit(ndState as any);
+assert(
+  ndResult.label !== "Continue",
+  `needs-discussion label should not be default "Continue", got: "${ndResult.label}"`,
+);
+assert(
+  ndResult.label.toLowerCase().includes("draft") || ndResult.label.toLowerCase().includes("discuss"),
+  `needs-discussion label should mention "draft" or "discuss", got: "${ndResult.label}"`,
+);
+assert(
+  ndResult.description.toLowerCase().includes("discussion") || ndResult.description.toLowerCase().includes("draft"),
+  `needs-discussion description should mention "discussion" or "draft", got: "${ndResult.description}"`,
+);
+
+// ─── Backward compatibility: pre-planning still works ──────────────────────
+
+const ppState = {
+  phase: "pre-planning" as const,
+  activeMilestone: { id: "M001", title: "Test" },
+  activeSlice: undefined,
+  activeTask: undefined,
+  milestoneRegistry: [],
+  nextAction: "",
+};
+
+const ppResult = describeNextUnit(ppState as any);
+assert(
+  ppResult.label === "Research & plan milestone",
+  `pre-planning label should be "Research & plan milestone", got: "${ppResult.label}"`,
+);
+
+// ─── Backward compatibility: executing still works ──────────────────────────
+
+const exState = {
+  phase: "executing" as const,
+  activeMilestone: { id: "M001", title: "Test" },
+  activeSlice: { id: "S01", title: "Test Slice" },
+  activeTask: { id: "T01", title: "Test Task" },
+  milestoneRegistry: [],
+  nextAction: "",
+};
+
+const exResult = describeNextUnit(exState as any);
+assert(
+  exResult.label.includes("T01"),
+  `executing label should include task ID, got: "${exResult.label}"`,
+);
+
+// ─── Static verification: needs-discussion in dispatchNextUnit ──────────────
+
+const autoSource = readFileSync(
+  join(import.meta.dirname, "..", "auto.ts"),
+  "utf-8",
+);
+
+// Check describeNextUnit has the case
+const hasDescribeCase = autoSource.includes('case "needs-discussion"');
+assert(hasDescribeCase, "auto.ts describeNextUnit should have 'needs-discussion' case");
+
+// Check dispatchNextUnit has the branch
+const hasDispatchBranch = autoSource.includes('state.phase === "needs-discussion"');
+assert(hasDispatchBranch, "auto.ts dispatchNextUnit should have 'needs-discussion' branch");
+
+// Check the dispatch branch calls stopAuto
+const dispatchIdx = autoSource.indexOf('state.phase === "needs-discussion"');
+const nextChunk = autoSource.slice(dispatchIdx, dispatchIdx + 600);
+assert(
+  nextChunk.includes("stopAuto"),
+  "needs-discussion dispatch branch should call stopAuto",
+);
+
+// Check notification includes /gsd guidance
+assert(
+  nextChunk.includes("/gsd"),
+  "needs-discussion notification should tell user to run /gsd",
+);
+
+// ─── Results ──────────────────────────────────────────────────────────────
+
+console.log(`\nauto-draft-pause: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/dist/resources/extensions/gsd/tests/auto-preflight.test.ts

@@ -0,0 +1,45 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runGSDDoctor, selectDoctorScope, filterDoctorIssues } from "../doctor.js";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertTrue, report } = createTestContext();
+const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));
+const gsd = join(tmpBase, ".gsd");
+
+mkdirSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+mkdirSync(join(gsd, "milestones", "M009", "slices", "S01", "tasks"), { recursive: true });
+
+writeFileSync(join(gsd, "milestones", "M001", "M001-ROADMAP.md"), `# M001: Historical\n\n## Slices\n- [x] **S01: Old Slice** \`risk:low\` \`depends:[]\`\n  > After this: old done\n`);
+writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Old Slice\n\n**Goal:** Old\n**Demo:** Old\n\n## Must-Haves\n- done\n\n## Tasks\n- [x] **T01: Old Task** \`est:5m\`\n  done\n`);
+writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# T01: Old Task\n\n**Done**\n\n## What Happened\nDone.\n\n## Diagnostics\n- log\n`);
+writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), `---\nid: S01\nparent: M001\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# S01: Old Slice\n\n**Done**\n\n## What Happened\nDone.\n\n## Verification\nDone.\n\n## Deviations\nNone\n\n## Known Limitations\nNone\n\n## Follow-ups\nNone\n\n## Files Created/Modified\n- \`x\` — x\n\n## Forward Intelligence\n\n### What the next slice should know\n- x\n\n### What's fragile\n- x\n\n### Authoritative diagnostics\n- x\n\n### What assumptions changed\n- x\n`);
+
+writeFileSync(join(gsd, "milestones", "M001", "M001-SUMMARY.md"), `---\nid: M001\nstatus: complete\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# M001: Historical\n\nComplete.\n`);
+
+writeFileSync(join(gsd, "milestones", "M009", "M009-ROADMAP.md"), `# M009: Active\n\n## Slices\n- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`\n  > After this: active works\n`);
+writeFileSync(join(gsd, "milestones", "M009", "slices", "S01", "S01-PLAN.md"), `# S01: Active Slice\n\n**Goal:** Active\n**Demo:** Active\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Active Task** \`est:5m\`\n  todo\n`);
+
+async function main(): Promise<void> {
+  const scope = await selectDoctorScope(tmpBase);
+  assertTrue(scope === "M009/S01", "active scope selected instead of historical milestone");
+
+  const scopedReport = await runGSDDoctor(tmpBase, { fix: false, scope });
+  const scopedBlocking = filterDoctorIssues(scopedReport.issues, { scope, includeWarnings: false });
+  assertTrue(scopedBlocking.length === 0, "no blocking issues in active scope");
+
+  const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
+  const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
+  assertTrue(historicalWarnings.length > 0, "full repo still contains historical warning drift");
+
+  rmSync(tmpBase, { recursive: true, force: true });
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/resources/extensions/gsd/tests/auto-secrets-gate.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Integration tests for the secrets collection gate in startAuto().
+ *
+ * Exercises getManifestStatus() → collectSecretsFromManifest() composition
+ * end-to-end using real filesystem state. Proves the three gate paths:
+ *   1. No manifest exists — gate skips silently
+ *   2. Pending keys exist — gate triggers collection
+ *   3. No pending keys — gate skips silently
+ *
+ * Uses temp directories with real .gsd/milestones/M001/ structure, mirroring
+ * the pattern from manifest-status.test.ts.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { getManifestStatus } from '../files.ts';
+import { collectSecretsFromManifest } from '../../get-secrets-from-user.ts';
+
+function makeTempDir(prefix: string): string {
+  const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Create the .gsd/milestones/M001/ directory structure and write a secrets manifest. */
+function writeManifest(base: string, content: string): void {
+  const mDir = join(base, '.gsd', 'milestones', 'M001');
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'M001-SECRETS.md'), content);
+}
+
+/** Stub ctx with hasUI: false — collectOneSecret returns null (skip), showSecretsSummary is a no-op. */
+function makeNoUICtx(cwd: string) {
+  return {
+    ui: {},
+    hasUI: false,
+    cwd,
+  };
+}
+
+// ─── Scenario 1: No manifest exists ──────────────────────────────────────────
+
+test('secrets gate: no manifest exists — getManifestStatus returns null', async () => {
+  const tmp = makeTempDir('gate-no-manifest');
+  try {
+    // No .gsd directory at all
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.strictEqual(result, null, 'should return null when no manifest file exists');
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Scenario 2: Pending keys exist ─────────────────────────────────────────
+
+test('secrets gate: pending keys exist — gate triggers collection, manifest updated on disk', async () => {
+  const tmp = makeTempDir('gate-pending');
+  const savedA = process.env.GSD_GATE_TEST_EXISTING;
+  try {
+    // Simulate one key already in env
+    process.env.GSD_GATE_TEST_EXISTING = 'already-here';
+
+    // Ensure pending keys are NOT in env
+    delete process.env.GSD_GATE_TEST_PEND_A;
+    delete process.env.GSD_GATE_TEST_PEND_B;
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### GSD_GATE_TEST_PEND_A
+
+**Service:** ServiceA
+**Status:** pending
+**Destination:** dotenv
+
+1. Get key A from dashboard
+
+### GSD_GATE_TEST_PEND_B
+
+**Service:** ServiceB
+**Status:** pending
+**Destination:** dotenv
+
+1. Get key B from dashboard
+
+### GSD_GATE_TEST_EXISTING
+
+**Service:** ServiceC
+**Status:** pending
+**Destination:** dotenv
+
+1. Already in env
+`);
+
+    // (a) Verify getManifestStatus shows pending keys
+    const status = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(status, null, 'manifest should exist');
+    assert.ok(status!.pending.length > 0, 'should have pending keys');
+    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B']);
+    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING']);
+
+    // (b) Call collectSecretsFromManifest with no-UI context
+    // With hasUI: false, collectOneSecret returns null → pending keys become "skipped"
+    const result = await collectSecretsFromManifest(tmp, 'M001', makeNoUICtx(tmp));
+
+    // (c) Verify return shape
+    assert.deepStrictEqual(result.applied, [], 'no keys applied (no UI to enter values)');
+    assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_A'), 'PEND_A should be skipped');
+    assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_B'), 'PEND_B should be skipped');
+    assert.deepStrictEqual(result.existingSkipped, ['GSD_GATE_TEST_EXISTING']);
+
+    // (d) Verify manifest on disk was updated — pending entries that went through
+    // collection are now "skipped". The existing-in-env entry retains its manifest
+    // status ("pending") because collectSecretsFromManifest only updates entries
+    // that flow through collectOneSecret. At runtime, getManifestStatus overrides
+    // env-present entries to "existing" regardless of manifest status.
+    const manifestPath = join(tmp, '.gsd', 'milestones', 'M001', 'M001-SECRETS.md');
+    const updatedContent = readFileSync(manifestPath, 'utf8');
+    assert.ok(
+      updatedContent.includes('**Status:** skipped'),
+      'formerly-pending entries should now have status "skipped" in the manifest file',
+    );
+    // Count: PEND_A → skipped, PEND_B → skipped, EXISTING stays pending on disk
+    const skippedMatches = updatedContent.match(/\*\*Status:\*\* skipped/g);
+    assert.strictEqual(skippedMatches?.length, 2, 'two entries should have status "skipped"');
+    const pendingMatches = updatedContent.match(/\*\*Status:\*\* pending/g);
+    assert.strictEqual(pendingMatches?.length, 1, 'one entry (existing-in-env) retains pending on disk');
+
+    // (e) Verify getManifestStatus now shows no pending
+    const statusAfter = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(statusAfter, null);
+    assert.deepStrictEqual(statusAfter!.pending, [], 'no pending keys after collection');
+  } finally {
+    delete process.env.GSD_GATE_TEST_EXISTING;
+    if (savedA !== undefined) process.env.GSD_GATE_TEST_EXISTING = savedA;
+    delete process.env.GSD_GATE_TEST_PEND_A;
+    delete process.env.GSD_GATE_TEST_PEND_B;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Scenario 3: No pending keys — all collected or in env ──────────────────
+
+test('secrets gate: no pending keys — getManifestStatus shows pending.length === 0', async () => {
+  const tmp = makeTempDir('gate-no-pending');
+  const savedKey = process.env.GSD_GATE_TEST_ENVKEY;
+  try {
+    process.env.GSD_GATE_TEST_ENVKEY = 'some-value';
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### ALREADY_COLLECTED
+
+**Service:** ServiceX
+**Status:** collected
+**Destination:** dotenv
+
+1. Was collected previously
+
+### ALREADY_SKIPPED
+
+**Service:** ServiceY
+**Status:** skipped
+**Destination:** dotenv
+
+1. Not needed
+
+### GSD_GATE_TEST_ENVKEY
+
+**Service:** ServiceZ
+**Status:** pending
+**Destination:** dotenv
+
+1. In env already
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null, 'manifest should exist');
+    assert.deepStrictEqual(result!.pending, [], 'no pending keys — gate would skip');
+    assert.deepStrictEqual(result!.collected, ['ALREADY_COLLECTED']);
+    assert.deepStrictEqual(result!.skipped, ['ALREADY_SKIPPED']);
+    assert.deepStrictEqual(result!.existing, ['GSD_GATE_TEST_ENVKEY']);
+  } finally {
+    delete process.env.GSD_GATE_TEST_ENVKEY;
+    if (savedKey !== undefined) process.env.GSD_GATE_TEST_ENVKEY = savedKey;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/dist/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from '../unit-runtime.ts';
+import { resolveAutoSupervisorConfig } from '../preferences.ts';
+
+test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
+  const supervisor = resolveAutoSupervisorConfig();
+  assert.equal(supervisor.soft_timeout_minutes, 20);
+  assert.equal(supervisor.idle_timeout_minutes, 10);
+  assert.equal(supervisor.hard_timeout_minutes, 30);
+});
+
+test('writeUnitRuntimeRecord persists progress and recovery metadata defaults', () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
+  const startedAt = 1234567890;
+
+  writeUnitRuntimeRecord(base, 'plan-milestone', 'M010', startedAt, {
+    phase: 'dispatched',
+    lastProgressAt: startedAt,
+    progressCount: 1,
+    lastProgressKind: 'dispatch',
+  });
+
+  const runtime = readUnitRuntimeRecord(base, 'plan-milestone', 'M010');
+  assert.ok(runtime);
+  assert.equal(runtime.phase, 'dispatched');
+  assert.equal(runtime.lastProgressAt, startedAt);
+  assert.equal(runtime.progressCount, 1);
+  assert.equal(runtime.lastProgressKind, 'dispatch');
+  assert.equal(runtime.recoveryAttempts, 0);
+});
+
+test('writeUnitRuntimeRecord keeps explicit recovery attempt fields', () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
+  const startedAt = 2234567890;
+
+  writeUnitRuntimeRecord(base, 'research-milestone', 'M011', startedAt, {
+    phase: 'timeout',
+    recoveryAttempts: 2,
+    lastRecoveryReason: 'idle',
+    lastProgressAt: startedAt + 50,
+    progressCount: 3,
+    lastProgressKind: 'recovery-retry',
+  });
+
+  const runtime = JSON.parse(readFileSync(join(base, '.gsd/runtime/units/research-milestone-M011.json'), 'utf8'));
+  assert.equal(runtime.recoveryAttempts, 2);
+  assert.equal(runtime.lastRecoveryReason, 'idle');
+  assert.equal(runtime.lastProgressKind, 'recovery-retry');
+});