gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/tests/gsd-recover.test.ts

@@ -0,0 +1,462 @@
+// gsd-recover.test.ts — Tests for the `gsd recover` recovery logic.
+// Verifies: populate DB → clear hierarchy → recover from markdown → state matches.
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  transaction,
+  getAllMilestones,
+  getMilestoneSlices,
+  getSliceTasks,
+  _getAdapter,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getMilestone,
+  getSlice,
+  getTask,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-recover-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ─── Fixture Content ──────────────────────────────────────────────────────
+
+const ROADMAP_M001 = `# M001: Recovery Test
+
+**Vision:** Test recovery round-trip.
+
+## Success Criteria
+
+- All recovery tests pass
+- State matches after round-trip
+
+
+## Slices
+
+- [x] **S01: Setup** \`risk:low\` \`depends:[]\`
+  > After this: Setup complete.
+
+- [ ] **S02: Core** \`risk:medium\` \`depends:[S01]\`
+  > After this: Core done.
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01 | S02 | setup artifacts | setup artifacts |
+`;
+
+const PLAN_S01_COMPLETE = `---
+estimated_steps: 2
+estimated_files: 1
+skills_used: []
+---
+
+# S01: Setup
+
+**Goal:** Setup fixtures.
+**Demo:** Tasks done.
+
+## Tasks
+
+- [x] **T01: Init** \`est:15m\`
+  Initialize things.
+  - Files: \`init.ts\`, \`config.ts\`
+  - Verify: \`node test-init.ts\`
+
+- [x] **T02: Config** \`est:10m\`
+  Configure things.
+  - Files: \`settings.ts\`
+  - Verify: \`node test-config.ts\`
+`;
+
+const PLAN_S02_PARTIAL = `---
+estimated_steps: 1
+estimated_files: 1
+skills_used: []
+---
+
+# S02: Core
+
+**Goal:** Build core.
+**Demo:** Core works.
+
+## Tasks
+
+- [x] **T01: Build** \`est:30m\`
+  Build it.
+  - Files: \`core.ts\`
+  - Verify: \`node test-build.ts\`
+
+- [ ] **T02: Test** \`est:20m\`
+  Test it.
+  - Files: \`test-core.ts\`, \`helpers.ts\`
+  - Verify: \`npm test\`
+
+- [ ] **T03: Polish** \`est:15m\`
+  Polish it.
+  - Files: \`polish.ts\`
+  - Verify: \`node test-polish.ts\`
+`;
+
+const SUMMARY_S01 = `---
+id: S01
+parent: M001
+milestone: M001
+---
+
+# S01: Setup — Summary
+
+Setup is complete.
+`;
+
+// ─── Recovery helpers (mirrors gsd recover handler logic) ─────────────────
+
+function clearHierarchyTables(): void {
+  const db = _getAdapter()!;
+  transaction(() => {
+    db.exec("DELETE FROM tasks");
+    db.exec("DELETE FROM slices");
+    db.exec("DELETE FROM milestones");
+  });
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+async function main() {
+  // ─── Test (a): Full recovery round-trip ─────────────────────────────────
+  console.log('\n=== recover: full round-trip (populate → clear → recover → verify) ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // Set up markdown fixtures
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_S01_COMPLETE);
+      writeFile(base, 'milestones/M001/slices/S01/S01-SUMMARY.md', SUMMARY_S01);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_S02_PARTIAL);
+
+      // Step 1: Open DB and populate from markdown
+      openDatabase(':memory:');
+      const counts1 = migrateHierarchyToDb(base);
+      assertEq(counts1.milestones, 1, 'round-trip: initial migration — 1 milestone');
+      assertEq(counts1.slices, 2, 'round-trip: initial migration — 2 slices');
+      assertTrue(counts1.tasks >= 5, 'round-trip: initial migration — at least 5 tasks');
+
+      // Step 2: Capture state from DB before clearing
+      invalidateStateCache();
+      const stateBefore = await deriveStateFromDb(base);
+      assertTrue(stateBefore.activeMilestone !== null, 'round-trip: state before has active milestone');
+      const milestonesBefore = getAllMilestones();
+      const slicesBefore = getMilestoneSlices('M001');
+      const s01TasksBefore = getSliceTasks('M001', 'S01');
+      const s02TasksBefore = getSliceTasks('M001', 'S02');
+
+      // Step 3: Clear hierarchy tables
+      clearHierarchyTables();
+      const milestonesAfterClear = getAllMilestones();
+      assertEq(milestonesAfterClear.length, 0, 'round-trip: milestones cleared');
+
+      // Step 4: Recover from markdown
+      const counts2 = migrateHierarchyToDb(base);
+      assertEq(counts2.milestones, counts1.milestones, 'round-trip: recovery milestone count matches');
+      assertEq(counts2.slices, counts1.slices, 'round-trip: recovery slice count matches');
+      assertEq(counts2.tasks, counts1.tasks, 'round-trip: recovery task count matches');
+
+      // Step 5: Verify state matches
+      invalidateStateCache();
+      const stateAfter = await deriveStateFromDb(base);
+
+      assertEq(stateAfter.phase, stateBefore.phase, 'round-trip: phase matches');
+      assertEq(
+        stateAfter.activeMilestone?.id,
+        stateBefore.activeMilestone?.id,
+        'round-trip: active milestone ID matches',
+      );
+      assertEq(
+        stateAfter.activeSlice?.id,
+        stateBefore.activeSlice?.id,
+        'round-trip: active slice ID matches',
+      );
+      assertEq(
+        stateAfter.activeTask?.id,
+        stateBefore.activeTask?.id,
+        'round-trip: active task ID matches',
+      );
+
+      // Verify row-level data matches
+      const milestonesAfter = getAllMilestones();
+      assertEq(milestonesAfter.length, milestonesBefore.length, 'round-trip: milestone row count');
+      assertEq(milestonesAfter[0]?.id, milestonesBefore[0]?.id, 'round-trip: milestone ID');
+      assertEq(milestonesAfter[0]?.title, milestonesBefore[0]?.title, 'round-trip: milestone title');
+
+      const slicesAfter = getMilestoneSlices('M001');
+      assertEq(slicesAfter.length, slicesBefore.length, 'round-trip: slice row count');
+      assertEq(slicesAfter[0]?.id, slicesBefore[0]?.id, 'round-trip: S01 ID');
+      assertEq(slicesAfter[0]?.status, slicesBefore[0]?.status, 'round-trip: S01 status');
+      assertEq(slicesAfter[1]?.id, slicesBefore[1]?.id, 'round-trip: S02 ID');
+
+      const s01TasksAfter = getSliceTasks('M001', 'S01');
+      assertEq(s01TasksAfter.length, s01TasksBefore.length, 'round-trip: S01 task count');
+
+      const s02TasksAfter = getSliceTasks('M001', 'S02');
+      assertEq(s02TasksAfter.length, s02TasksBefore.length, 'round-trip: S02 task count');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test (a2): v8 planning columns populated after recovery ───────────
+  console.log('\n=== recover: v8 planning columns populated ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_S01_COMPLETE);
+      writeFile(base, 'milestones/M001/slices/S01/S01-SUMMARY.md', SUMMARY_S01);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_S02_PARTIAL);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      // Milestone planning columns
+      const milestone = getMilestone('M001');
+      assertTrue(milestone !== null, 'v8: milestone exists');
+      assertEq(milestone!.vision, 'Test recovery round-trip.', 'v8: milestone vision populated');
+      assertTrue(milestone!.success_criteria.length >= 2, 'v8: milestone success_criteria has entries');
+      assertEq(milestone!.success_criteria[0], 'All recovery tests pass', 'v8: first success criterion');
+      assertTrue(milestone!.boundary_map_markdown.includes('Boundary Map'), 'v8: boundary_map_markdown populated');
+      assertTrue(milestone!.boundary_map_markdown.includes('S01'), 'v8: boundary_map_markdown has S01');
+
+      // Tool-only fields left empty per D004
+      assertEq(milestone!.key_risks.length, 0, 'v8: key_risks left empty (tool-only per D004)');
+      assertEq(milestone!.requirement_coverage, '', 'v8: requirement_coverage left empty (tool-only per D004)');
+
+      // Slice planning columns
+      const sliceS01 = getSlice('M001', 'S01');
+      assertTrue(sliceS01 !== null, 'v8: slice S01 exists');
+      assertEq(sliceS01!.goal, 'Setup fixtures.', 'v8: S01 goal populated');
+
+      const sliceS02 = getSlice('M001', 'S02');
+      assertTrue(sliceS02 !== null, 'v8: slice S02 exists');
+      assertEq(sliceS02!.goal, 'Build core.', 'v8: S02 goal populated');
+
+      // Slice tool-only fields left empty per D004
+      assertEq(sliceS01!.proof_level, '', 'v8: S01 proof_level left empty (tool-only per D004)');
+
+      // Task planning columns — S01/T01
+      const taskS01T01 = getTask('M001', 'S01', 'T01');
+      assertTrue(taskS01T01 !== null, 'v8: task S01/T01 exists');
+      assertTrue(taskS01T01!.files.length >= 2, 'v8: S01/T01 files populated');
+      assertTrue(taskS01T01!.files.includes('init.ts'), 'v8: S01/T01 files includes init.ts');
+      assertTrue(taskS01T01!.files.includes('config.ts'), 'v8: S01/T01 files includes config.ts');
+      assertEq(taskS01T01!.verify, '`node test-init.ts`', 'v8: S01/T01 verify populated');
+
+      // Task planning columns — S02/T02
+      const taskS02T02 = getTask('M001', 'S02', 'T02');
+      assertTrue(taskS02T02 !== null, 'v8: task S02/T02 exists');
+      assertTrue(taskS02T02!.files.length >= 2, 'v8: S02/T02 files populated');
+      assertTrue(taskS02T02!.files.includes('test-core.ts'), 'v8: S02/T02 files includes test-core.ts');
+      assertEq(taskS02T02!.verify, '`npm test`', 'v8: S02/T02 verify populated');
+
+      // Task with no Files/Verify — not applicable since all fixtures now have them,
+      // but confirm a task from S02 has correct data
+      const taskS02T03 = getTask('M001', 'S02', 'T03');
+      assertTrue(taskS02T03 !== null, 'v8: task S02/T03 exists');
+      assertTrue(taskS02T03!.files.includes('polish.ts'), 'v8: S02/T03 files includes polish.ts');
+      assertEq(taskS02T03!.verify, '`node test-polish.ts`', 'v8: S02/T03 verify populated');
+
+      // Diagnostic: v8 planning columns queryable via SQL
+      const db = _getAdapter()!;
+      const milestoneRow = db.prepare("SELECT vision, success_criteria, boundary_map_markdown FROM milestones WHERE id = 'M001'").get() as any;
+      assertTrue(milestoneRow.vision.length > 0, 'v8-diag: vision column queryable');
+      assertTrue(milestoneRow.boundary_map_markdown.length > 0, 'v8-diag: boundary_map_markdown column queryable');
+
+      const sliceRow = db.prepare("SELECT goal FROM slices WHERE milestone_id = 'M001' AND id = 'S01'").get() as any;
+      assertTrue(sliceRow.goal.length > 0, 'v8-diag: goal column queryable');
+
+      const taskRow = db.prepare("SELECT files, verify FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'").get() as any;
+      assertTrue(taskRow.files.length > 2, 'v8-diag: files column queryable (JSON array)');
+      assertTrue(taskRow.verify.length > 0, 'v8-diag: verify column queryable');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+
+  // ─── Test (b): Idempotent recovery — double recover ────────────────────
+  console.log('\n=== recover: idempotent — double recovery produces same state ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_S01_COMPLETE);
+      writeFile(base, 'milestones/M001/slices/S01/S01-SUMMARY.md', SUMMARY_S01);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_S02_PARTIAL);
+
+      openDatabase(':memory:');
+
+      // First recovery
+      migrateHierarchyToDb(base);
+      invalidateStateCache();
+      const state1 = await deriveStateFromDb(base);
+
+      // Clear and recover again
+      clearHierarchyTables();
+      migrateHierarchyToDb(base);
+      invalidateStateCache();
+      const state2 = await deriveStateFromDb(base);
+
+      assertEq(state2.phase, state1.phase, 'idempotent: phase matches');
+      assertEq(
+        state2.activeMilestone?.id,
+        state1.activeMilestone?.id,
+        'idempotent: active milestone matches',
+      );
+      assertEq(
+        state2.activeSlice?.id,
+        state1.activeSlice?.id,
+        'idempotent: active slice matches',
+      );
+      assertEq(
+        state2.activeTask?.id,
+        state1.activeTask?.id,
+        'idempotent: active task matches',
+      );
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test (c): Recovery preserves non-hierarchy data ───────────────────
+  console.log('\n=== recover: preserves decisions/requirements ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_S01_COMPLETE);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      // Insert a decision and requirement manually
+      const db = _getAdapter()!;
+      db.prepare(
+        `INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable)
+         VALUES (:id, :when, :scope, :decision, :choice, :rationale, :revisable)`,
+      ).run({
+        ':id': 'D001',
+        ':when': 'T03',
+        ':scope': 'architecture',
+        ':decision': 'Use shared WAL',
+        ':choice': 'Single DB',
+        ':rationale': 'Simpler',
+        ':revisable': 'Yes',
+      });
+
+      db.prepare(
+        `INSERT INTO requirements (id, class, status, description)
+         VALUES (:id, :class, :status, :desc)`,
+      ).run({
+        ':id': 'R001',
+        ':class': 'functional',
+        ':status': 'active',
+        ':desc': 'Recovery works',
+      });
+
+      // Clear hierarchy only
+      clearHierarchyTables();
+
+      // Verify decisions and requirements survived
+      const decisions = db.prepare('SELECT * FROM decisions').all();
+      assertEq(decisions.length, 1, 'preserve: decision survives clear');
+      assertEq((decisions[0] as any).id, 'D001', 'preserve: decision ID intact');
+
+      const requirements = db.prepare('SELECT * FROM requirements').all();
+      assertEq(requirements.length, 1, 'preserve: requirement survives clear');
+      assertEq((requirements[0] as any).id, 'R001', 'preserve: requirement ID intact');
+
+      // Recover hierarchy
+      migrateHierarchyToDb(base);
+      const milestones = getAllMilestones();
+      assertTrue(milestones.length > 0, 'preserve: milestones recovered after clear');
+
+      // Verify non-hierarchy data still intact after recovery
+      const decisionsAfter = db.prepare('SELECT * FROM decisions').all();
+      assertEq(decisionsAfter.length, 1, 'preserve: decision still present after recovery');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test (d): Recovery from empty markdown dir ────────────────────────
+  console.log('\n=== recover: empty milestones dir ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // No milestones written — just the empty dir
+      openDatabase(':memory:');
+
+      // Pre-populate to simulate existing state
+      insertMilestone({ id: 'M001', title: 'Ghost', status: 'active' });
+
+      // Clear and recover from empty
+      clearHierarchyTables();
+      const counts = migrateHierarchyToDb(base);
+      assertEq(counts.milestones, 0, 'empty: zero milestones recovered');
+      assertEq(counts.slices, 0, 'empty: zero slices recovered');
+      assertEq(counts.tasks, 0, 'empty: zero tasks recovered');
+
+      const all = getAllMilestones();
+      assertEq(all.length, 0, 'empty: no milestones in DB after recovery');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/idle-recovery.test.ts

@@ -5,7 +5,6 @@ import { execSync } from "node:child_process";
 import {
   resolveExpectedArtifactPath,
   writeBlockerPlaceholder,
-  skipExecuteTask,
   verifyExpectedArtifact,
   buildLoopRemediationSteps,
 } from "../auto.ts";
@@ -157,129 +156,6 @@ function cleanup(base: string): void {
   }
 }
 
-// ═══ skipExecuteTask ═════════════════════════════════════════════════════════
-
-{
-  console.log("\n=== skipExecuteTask: writes summary and checks plan checkbox ===");
-  const base = createFixtureBase();
-  try {
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    writeFileSync(planPath, [
-      "# S01: Test Slice",
-      "",
-      "## Tasks",
-      "",
-      "- [ ] **T01: First task** `est:10m`",
-      "  Do the first thing.",
-      "- [ ] **T02: Second task** `est:15m`",
-      "  Do the second thing.",
-    ].join("\n"), "utf-8");
-
-    const result = skipExecuteTask(
-      base, "M001", "S01", "T01",
-      { summaryExists: false, taskChecked: false },
-      "idle", 2,
-    );
-
-    assertTrue(result === true, "should return true");
-
-    // Check summary was written
-    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
-    assertTrue(existsSync(summaryPath), "task summary should exist");
-    const summaryContent = readFileSync(summaryPath, "utf-8");
-    assertTrue(summaryContent.includes("BLOCKER"), "summary should contain BLOCKER");
-    assertTrue(summaryContent.includes("T01"), "summary should mention task ID");
-
-    // Check plan checkbox was marked
-    const planContent = readFileSync(planPath, "utf-8");
-    assertTrue(planContent.includes("- [x] **T01:"), "T01 should be checked");
-    assertTrue(planContent.includes("- [ ] **T02:"), "T02 should remain unchecked");
-  } finally {
-    cleanup(base);
-  }
-}
-
-{
-  console.log("\n=== skipExecuteTask: skips summary if already exists ===");
-  const base = createFixtureBase();
-  try {
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    writeFileSync(planPath, "- [ ] **T01: Task** `est:10m`\n", "utf-8");
-
-    // Pre-write a summary
-    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
-    writeFileSync(summaryPath, "# Real summary\nActual work done.", "utf-8");
-
-    const result = skipExecuteTask(
-      base, "M001", "S01", "T01",
-      { summaryExists: true, taskChecked: false },
-      "idle", 2,
-    );
-
-    assertTrue(result === true, "should return true");
-
-    // Summary should be untouched (not overwritten with blocker)
-    const content = readFileSync(summaryPath, "utf-8");
-    assertTrue(content.includes("Real summary"), "original summary should be preserved");
-    assertTrue(!content.includes("BLOCKER"), "should not contain BLOCKER");
-
-    // Plan checkbox should still be marked
-    const planContent = readFileSync(planPath, "utf-8");
-    assertTrue(planContent.includes("- [x] **T01:"), "T01 should be checked");
-  } finally {
-    cleanup(base);
-  }
-}
-
-{
-  console.log("\n=== skipExecuteTask: skips checkbox if already checked ===");
-  const base = createFixtureBase();
-  try {
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    writeFileSync(planPath, "- [x] **T01: Task** `est:10m`\n", "utf-8");
-
-    const result = skipExecuteTask(
-      base, "M001", "S01", "T01",
-      { summaryExists: false, taskChecked: true },
-      "idle", 2,
-    );
-
-    assertTrue(result === true, "should return true");
-
-    // Summary should be written (since summaryExists was false)
-    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
-    assertTrue(existsSync(summaryPath), "task summary should exist");
-
-    // Plan checkbox should be untouched
-    const planContent = readFileSync(planPath, "utf-8");
-    assertTrue(planContent.includes("- [x] **T01:"), "T01 should remain checked");
-  } finally {
-    cleanup(base);
-  }
-}
-
-{
-  console.log("\n=== skipExecuteTask: handles special regex chars in task ID ===");
-  const base = createFixtureBase();
-  try {
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    writeFileSync(planPath, "- [ ] **T01.1: Sub-task** `est:10m`\n", "utf-8");
-
-    const result = skipExecuteTask(
-      base, "M001", "S01", "T01.1",
-      { summaryExists: false, taskChecked: false },
-      "idle", 2,
-    );
-
-    assertTrue(result === true, "should return true");
-
-    const planContent = readFileSync(planPath, "utf-8");
-    assertTrue(planContent.includes("- [x] **T01.1:"), "T01.1 should be checked (regex chars escaped)");
-  } finally {
-    cleanup(base);
-  }
-}
-
 // ═══ verifyExpectedArtifact: complete-slice roadmap check ════════════════════
 // Regression for #indefinite-hang: complete-slice must verify roadmap [x] or
 // the idempotency skip loops forever after a crash that wrote SUMMARY+UAT but
@@ -370,12 +246,9 @@ const ROADMAP_COMPLETE = `# M001: Test Milestone
     mkdirSync(join(base, ".gsd", "milestones", "M002", "slices", "S03", "tasks"), { recursive: true });
     const result = buildLoopRemediationSteps("execute-task", "M002/S03/T01", base);
     assertTrue(result !== null, "should return remediation steps");
-    assertTrue(result!.includes("T01-SUMMARY.md"), "steps mention the summary file");
-    assertTrue(result!.includes("S03-PLAN.md"), "steps mention the slice plan");
+    assertTrue(result!.includes("gsd undo-task"), "steps include undo-task command");
     assertTrue(result!.includes("T01"), "steps mention the task ID");
-    assertTrue(result!.includes("gsd doctor"), "steps include gsd doctor command");
-    // Exact slice plan checkbox syntax (no trailing **)
-    assertTrue(result!.includes('"- [x] **T01:"'), "steps show exact checkbox syntax without trailing **");
+    assertTrue(result!.includes("gsd undo-task"), "steps include gsd undo-task command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
@@ -389,7 +262,7 @@ const ROADMAP_COMPLETE = `# M001: Test Milestone
     const result = buildLoopRemediationSteps("plan-slice", "M001/S01", base);
     assertTrue(result !== null, "should return remediation steps for plan-slice");
     assertTrue(result!.includes("S01-PLAN.md"), "steps mention the slice plan file");
-    assertTrue(result!.includes("gsd doctor"), "steps include gsd doctor command");
+    assertTrue(result!.includes("gsd recover"), "steps include gsd recover command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
@@ -403,7 +276,7 @@ const ROADMAP_COMPLETE = `# M001: Test Milestone
     const result = buildLoopRemediationSteps("research-slice", "M001/S01", base);
     assertTrue(result !== null, "should return remediation steps for research-slice");
     assertTrue(result!.includes("S01-RESEARCH.md"), "steps mention the slice research file");
-    assertTrue(result!.includes("gsd doctor"), "steps include gsd doctor command");
+    assertTrue(result!.includes("gsd recover"), "steps include gsd recover command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
@@ -420,47 +293,6 @@ const ROADMAP_COMPLETE = `# M001: Test Milestone
   }
 }
 
-{
-  console.log("\n=== skipExecuteTask: loop-recovery writes blocker when both summary and checkbox missing ===");
-  const base = mkdtempSync(join(tmpdir(), "gsd-loop-recovery-test-"));
-  try {
-    mkdirSync(join(base, ".gsd", "milestones", "M002", "slices", "S03", "tasks"), { recursive: true });
-    const planPath = join(base, ".gsd", "milestones", "M002", "slices", "S03", "S03-PLAN.md");
-    writeFileSync(planPath, [
-      "# S03: Harden guided session",
-      "",
-      "## Tasks",
-      "",
-      "- [ ] **T01: Harden contract usage** `est:30m`",
-      "  Harden guided session contract usage in desktop flow.",
-    ].join("\n"), "utf-8");
-
-    const result = skipExecuteTask(
-      base, "M002", "S03", "T01",
-      { summaryExists: false, taskChecked: false },
-      "loop-recovery",
-      // 3 == MAX_UNIT_DISPATCHES: represents the prevCount when the final
-      // reconciliation path runs (loop detected, reconciling before halting).
-      3,
-    );
-
-    assertTrue(result === true, "loop-recovery should succeed");
-
-    // Blocker summary written
-    const summaryPath = join(base, ".gsd", "milestones", "M002", "slices", "S03", "tasks", "T01-SUMMARY.md");
-    assertTrue(existsSync(summaryPath), "blocker summary should be written");
-    const summaryContent = readFileSync(summaryPath, "utf-8");
-    assertTrue(summaryContent.includes("BLOCKER"), "summary should be a blocker placeholder");
-    assertTrue(summaryContent.includes("loop-recovery"), "summary should mention the recovery reason");
-
-    // Checkbox marked
-    const planContent = readFileSync(planPath, "utf-8");
-    assertTrue(planContent.includes("- [x] **T01:"), "T01 checkbox should be marked [x] after loop-recovery");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-}
-
 // ═══ verifyExpectedArtifact: hook unit types ═════════════════════════════════
 
 console.log("\n=== verifyExpectedArtifact: hook types always return true ===");