gsd-pi 2.41.0-dev.9446b20 → 2.41.0-dev.b832948

package/src/resources/extensions/gsd/tests/doctor-completion-deferral.test.ts

@@ -80,7 +80,7 @@ test("COMPLETION_TRANSITION_CODES only contains slice summary code", () => {
   );
 });
 
-test("fixLevel:task — fixes roadmap checkbox and UAT stub immediately, defers only summary (#1808)", async () => {
+test("fixLevel:task — fixes UAT stub immediately, defers summary and roadmap checkbox (#1808, #1910)", async () => {
   const tmp = makeTmp("partial-deferral");
   try {
     buildScaffold(tmp);
@@ -101,15 +101,16 @@ test("fixLevel:task — fixes roadmap checkbox and UAT stub immediately, defers
     const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
     assert.ok(existsSync(sliceUatPath), "should have created UAT stub immediately");
 
-    // Roadmap checkbox SHOULD be marked done (mechanical bookkeeping, no longer deferred)
+    // Roadmap checkbox must NOT be checked without summary on disk (#1910).
+    // Checking it without the summary causes deriveState() to skip complete-slice.
     const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary on disk (#1910)");
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }
 });
 
-test("fixLevel:task — session crash after last task leaves roadmap and UAT consistent (#1808)", async () => {
+test("fixLevel:task — session crash after last task leaves UAT consistent, roadmap deferred with summary (#1808, #1910)", async () => {
   const tmp = makeTmp("crash-consistency");
   try {
     buildScaffold(tmp);
@@ -121,13 +122,7 @@ test("fixLevel:task — session crash after last task leaves roadmap and UAT con
     // A new session starts and runs doctor again at task level.
     const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
 
-    // The only remaining issue should be the deferred summary.
-    // Roadmap and UAT should already be fixed from the first run.
     const remainingCodes = report2.issues.map(i => i.code);
-    assert.ok(
-      !remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
-      "roadmap should already be fixed from first doctor run"
-    );
     assert.ok(
       !remainingCodes.includes("all_tasks_done_missing_slice_uat"),
       "UAT should already be fixed from first doctor run"
@@ -137,6 +132,16 @@ test("fixLevel:task — session crash after last task leaves roadmap and UAT con
       remainingCodes.includes("all_tasks_done_missing_slice_summary"),
       "summary should still be detected as missing (deferred)"
     );
+    // Roadmap should still be unchecked because summary doesn't exist (#1910)
+    assert.ok(
+      remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
+      "roadmap should still be unchecked — summary does not exist on disk (#1910)"
+    );
+    // Must NOT produce the cascade error from checking roadmap without summary
+    assert.ok(
+      !remainingCodes.includes("slice_checked_missing_summary"),
+      "must not produce slice_checked_missing_summary (#1910)"
+    );
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/doctor-fixlevel.test.ts

@@ -63,7 +63,7 @@ Done.
 `);
 }
 
-test("fixLevel:task — defers only summary stub, fixes roadmap and UAT immediately (#1808)", async () => {
+test("fixLevel:task — defers summary stub and roadmap checkbox, fixes UAT immediately (#1808, #1910)", async () => {
   const tmp = makeTmp("task-level");
   try {
     buildScaffold(tmp);
@@ -79,13 +79,14 @@ test("fixLevel:task — defers only summary stub, fixes roadmap and UAT immediat
     const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
     assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
 
-    // Roadmap SHOULD be marked done (mechanical bookkeeping, no longer deferred)
+    // Roadmap must NOT be checked without summary on disk (#1910)
     const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary (#1910)");
 
-    // Fixes applied should NOT include summary but SHOULD include roadmap
+    // Fixes applied should NOT include summary or roadmap
     for (const f of report.fixesApplied) {
       assert.ok(!f.includes("SUMMARY"), `should not have fixed summary: ${f}`);
+      assert.ok(!f.includes("ROADMAP") && !f.includes("roadmap"), `should not have fixed roadmap: ${f}`);
     }
   } finally {
     rmSync(tmp, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/doctor-roadmap-summary-atomicity.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Regression test for #1910: Doctor marks roadmap checkbox at fixLevel="task"
+ * without summary on disk, causing deriveState() to skip complete-slice and
+ * hard-stop at validating-milestone.
+ *
+ * The roadmap checkbox must only be marked when the slice summary actually
+ * exists on disk (either pre-existing or created in the current doctor run).
+ * At fixLevel="task", the summary is deferred (COMPLETION_TRANSITION_CODES),
+ * so the roadmap checkbox must also be deferred.
+ */
+
+import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runGSDDoctor } from "../doctor.ts";
+
+function makeTmp(name: string): string {
+  const dir = join(tmpdir(), `doctor-roadmap-summary-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Build a minimal .gsd structure: milestone with one slice, one task
+ * marked done with a summary — but no slice summary and roadmap unchecked.
+ * This is the state after the last task completes.
+ */
+function buildScaffold(base: string) {
+  const gsd = join(base, ".gsd");
+  const m = join(gsd, "milestones", "M001");
+  const s = join(m, "slices", "S01", "tasks");
+  mkdirSync(s, { recursive: true });
+
+  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > Demo text
+`);
+
+  writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+
+**Goal:** test
+
+## Tasks
+
+- [x] **T01: Do stuff** \`est:5m\`
+`);
+
+  writeFileSync(join(s, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+duration: 5m
+verification_result: passed
+completed_at: 2026-01-01
+---
+
+# T01: Do stuff
+
+Done.
+`);
+}
+
+test("fixLevel:task — must NOT mark roadmap checkbox when summary does not exist on disk (#1910)", async () => {
+  const tmp = makeTmp("no-roadmap-without-summary");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Doctor should detect both issues
+    const codes = report.issues.map(i => i.code);
+    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
+    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
+
+    // Summary should NOT exist (deferred at task level)
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created (deferred)");
+
+    // CRITICAL: Roadmap checkbox must NOT be checked without summary on disk.
+    // If it is checked, deriveState() sees the milestone as complete and skips
+    // the summarizing phase, causing a hard-stop at validating-milestone.
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(
+      roadmapContent.includes("- [ ] **S01"),
+      "roadmap must NOT mark S01 as checked when summary does not exist on disk"
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:task — consecutive runs must not produce slice_checked_missing_summary (#1910)", async () => {
+  const tmp = makeTmp("no-cascade-error");
+  try {
+    buildScaffold(tmp);
+
+    // First doctor run at task level
+    await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Second doctor run — if the first run incorrectly checked the roadmap,
+    // this run would detect slice_checked_missing_summary (the cascade error
+    // described in the issue's forensic evidence).
+    const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+    const codes2 = report2.issues.map(i => i.code);
+
+    assert.ok(
+      !codes2.includes("slice_checked_missing_summary"),
+      "must not produce slice_checked_missing_summary — roadmap should not have been checked without summary"
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:all — roadmap checkbox IS marked because summary is created in same run (#1910)", async () => {
+  const tmp = makeTmp("all-level-creates-both");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true });
+
+    // At fixLevel:all, summary stub is created first, then roadmap is checked.
+    // Both should be fixed.
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(existsSync(sliceSummaryPath), "summary should be created at fixLevel:all");
+
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked at fixLevel:all");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:task — roadmap IS marked when summary already exists on disk (#1910)", async () => {
+  const tmp = makeTmp("summary-preexists");
+  try {
+    buildScaffold(tmp);
+
+    // Pre-create the slice summary (as if complete-slice already ran)
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    writeFileSync(sliceSummaryPath, `---
+id: S01
+milestone: M001
+---
+
+# S01: Test Slice
+
+Summary content.
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Summary exists, so roadmap SHOULD be checked even at task level
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(
+      roadmapContent.includes("- [x] **S01"),
+      "roadmap should be checked when summary already exists on disk"
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/doctor-task-done-missing-summary-slice-loop.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Regression test for #1850: doctor task_done_missing_summary fix leaves
+ * slice [x] done in roadmap, causing an infinite doctor loop.
+ *
+ * Scenario: A slice is [x] done in the roadmap, has S01-SUMMARY.md (so
+ * slice_checked_missing_summary never fires), but tasks are [x] done with
+ * no T##-SUMMARY.md files. Doctor unchecks the tasks but must also uncheck
+ * the slice so the state machine re-enters the executing phase.
+ */
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runGSDDoctor } from "../doctor.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  // ─── Setup: slice [x] done with S01-SUMMARY.md, tasks [x] but NO task summaries ───
+  console.log("\n=== #1850: task_done_missing_summary fix must also uncheck slice ===");
+  {
+    const base = mkdtempSync(join(tmpdir(), "gsd-doctor-1850-"));
+    const gsd = join(base, ".gsd");
+    const mDir = join(gsd, "milestones", "M001");
+    const sDir = join(mDir, "slices", "S01");
+    const tDir = join(sDir, "tasks");
+    mkdirSync(tDir, { recursive: true });
+
+    // Roadmap: slice is [x] done
+    writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Test Milestone
+
+## Slices
+- [x] **S01: Guided Slice** \`risk:low\` \`depends:[]\`
+  > After this: guided flow works
+`);
+
+    // Plan: tasks are [x] done
+    writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Guided Slice
+
+**Goal:** Test guided flow
+**Demo:** Works
+
+## Tasks
+- [x] **T01: First task** \`est:10m\`
+  Do the first thing.
+- [x] **T02: Second task** \`est:10m\`
+  Do the second thing.
+- [x] **T03: Third task** \`est:10m\`
+  Do the third thing.
+`);
+
+    // Slice summary EXISTS (so slice_checked_missing_summary guard does NOT fire)
+    writeFileSync(join(sDir, "S01-SUMMARY.md"), `---
+id: S01
+parent: M001
+---
+# S01: Guided Slice
+Done via guided flow.
+`);
+
+    // Slice UAT exists
+    writeFileSync(join(sDir, "S01-UAT.md"), `# S01 UAT
+Verified.
+`);
+
+    // NO task summaries on disk — this is the trigger condition
+
+    // ── First pass: diagnose ──
+    const diagReport = await runGSDDoctor(base, { fix: false });
+    const taskDoneMissing = diagReport.issues.filter(i => i.code === "task_done_missing_summary");
+    assertEq(taskDoneMissing.length, 3, "detects 3 tasks with task_done_missing_summary");
+
+    // ── Second pass: fix ──
+    const fixReport = await runGSDDoctor(base, { fix: true });
+
+    // Tasks should be unchecked in plan
+    const plan = readFileSync(join(sDir, "S01-PLAN.md"), "utf-8");
+    assertTrue(plan.includes("- [ ] **T01:"), "T01 is unchecked in plan after fix");
+    assertTrue(plan.includes("- [ ] **T02:"), "T02 is unchecked in plan after fix");
+    assertTrue(plan.includes("- [ ] **T03:"), "T03 is unchecked in plan after fix");
+
+    // CRITICAL: Slice must also be unchecked in roadmap to prevent infinite loop
+    const roadmap = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
+    assertTrue(
+      roadmap.includes("- [ ] **S01:"),
+      "slice is unchecked in roadmap after task_done_missing_summary fix (prevents infinite loop)"
+    );
+    assertTrue(
+      !roadmap.includes("- [x] **S01:"),
+      "slice is NOT still [x] done in roadmap"
+    );
+
+    // ── Third pass: re-run doctor should NOT re-detect task_done_missing_summary ──
+    const rerunReport = await runGSDDoctor(base, { fix: false });
+    const rerunTaskDone = rerunReport.issues.filter(i => i.code === "task_done_missing_summary");
+    assertEq(rerunTaskDone.length, 0, "no task_done_missing_summary on re-run (no infinite loop)");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ─── Partial fix: only some tasks missing summaries ───
+  console.log("\n=== #1850: partial — some tasks have summaries, some do not ===");
+  {
+    const base = mkdtempSync(join(tmpdir(), "gsd-doctor-1850-partial-"));
+    const gsd = join(base, ".gsd");
+    const mDir = join(gsd, "milestones", "M001");
+    const sDir = join(mDir, "slices", "S01");
+    const tDir = join(sDir, "tasks");
+    mkdirSync(tDir, { recursive: true });
+
+    writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Test Milestone
+
+## Slices
+- [x] **S01: Partial Slice** \`risk:low\` \`depends:[]\`
+  > After this: partial
+`);
+
+    writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Partial Slice
+
+**Goal:** Test partial
+**Demo:** Works
+
+## Tasks
+- [x] **T01: Has summary** \`est:10m\`
+  This task has a summary.
+- [x] **T02: Missing summary** \`est:10m\`
+  This task does not.
+`);
+
+    // T01 has a summary, T02 does not
+    writeFileSync(join(tDir, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+---
+# T01: Has summary
+**Done**
+## What Happened
+Done.
+`);
+
+    writeFileSync(join(sDir, "S01-SUMMARY.md"), `---
+id: S01
+parent: M001
+---
+# S01: Partial
+`);
+
+    writeFileSync(join(sDir, "S01-UAT.md"), `# S01 UAT
+Done.
+`);
+
+    const fixReport = await runGSDDoctor(base, { fix: true });
+
+    // T02 should be unchecked, T01 should stay checked
+    const plan = readFileSync(join(sDir, "S01-PLAN.md"), "utf-8");
+    assertTrue(plan.includes("- [x] **T01:"), "T01 stays checked (has summary)");
+    assertTrue(plan.includes("- [ ] **T02:"), "T02 is unchecked (missing summary)");
+
+    // Slice must be unchecked because not all tasks are done anymore
+    const roadmap = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
+    assertTrue(
+      roadmap.includes("- [ ] **S01:"),
+      "slice is unchecked when any task is unchecked by task_done_missing_summary"
+    );
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/exit-command.test.ts

@@ -48,3 +48,58 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
   assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
   assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
 });
+
+// ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
+
+test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async () => {
+  const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
+
+  const pi = {
+    registerCommand(name: string, options: any) {
+      commands.set(name, options);
+    },
+  };
+
+  // Simulate the ESM cache mismatch: stopAuto throws because a static import
+  // in the dependency chain references an export absent from the cached module.
+  registerExitCommand(pi as any, {
+    async stopAuto() {
+      throw new Error(
+        "The requested module './native-git-bridge.js' does not provide an export named 'nativeAddAllWithExclusions'",
+      );
+    },
+  });
+
+  const exit = commands.get("exit")!;
+
+  let shutdownCalls = 0;
+  const notifications: Array<{ msg: string; level: string }> = [];
+
+  const originalExit = process.exit;
+  process.exit = ((code?: number) => {
+    throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
+  }) as typeof process.exit;
+
+  try {
+    await exit.handler("", {
+      async shutdown() {
+        shutdownCalls += 1;
+      },
+      ui: {
+        notify(msg: string, level: string) {
+          notifications.push({ msg, level });
+        },
+      },
+    });
+  } finally {
+    process.exit = originalExit;
+  }
+
+  assert.equal(shutdownCalls, 1, "shutdown must still be called even when stopAuto throws");
+  assert.equal(notifications.length, 1, "should emit exactly one warning notification");
+  assert.equal(notifications[0].level, "warning", "notification level should be warning");
+  assert.ok(
+    notifications[0].msg.includes("module version mismatch"),
+    "notification should mention module version mismatch",
+  );
+});

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

@@ -66,7 +66,7 @@ console.log('\n=== gsd-db: fresh DB schema init (memory) ===');
   // Check schema_version table
   const adapter = _getAdapter()!;
   const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-  assertEq(version?.['version'], 3, 'schema version should be 3');
+  assertEq(version?.['version'], 4, 'schema version should be 4');
 
   // Check tables exist by querying them
   const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();
@@ -93,6 +93,7 @@ console.log('\n=== gsd-db: double-init idempotency ===');
     choice: 'option A',
     rationale: 'because',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -123,6 +124,7 @@ console.log('\n=== gsd-db: insert + get decision ===');
     choice: 'node:sqlite',
     rationale: 'built-in, zero deps',
     revisable: 'yes, if perf insufficient',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -186,6 +188,7 @@ console.log('\n=== gsd-db: active_decisions view excludes superseded ===');
     choice: 'JSON',
     rationale: 'simple',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: 'D002',  // superseded!
   });
 
@@ -197,6 +200,7 @@ console.log('\n=== gsd-db: active_decisions view excludes superseded ===');
     choice: 'SQLite',
     rationale: 'better querying',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,  // active
   });
 
@@ -208,6 +212,7 @@ console.log('\n=== gsd-db: active_decisions view excludes superseded ===');
     choice: 'WAL',
     rationale: 'concurrent reads',
     revisable: 'no',
+    made_by: 'agent',
     superseded_by: null,  // active
   });
 
@@ -294,6 +299,7 @@ console.log('\n=== gsd-db: transaction rollback on error ===');
     choice: 'test',
     rationale: 'test',
     revisable: 'test',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -309,6 +315,7 @@ console.log('\n=== gsd-db: transaction rollback on error ===');
         choice: 'test',
         rationale: 'test',
         revisable: 'test',
+        made_by: 'agent',
         superseded_by: null,
       });
       throw new Error('intentional failure');

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

@@ -1,6 +1,6 @@
 // gsd-tools — Structured LLM tool tests
 //
-// Tests the three registered tools: gsd_save_decision, gsd_update_requirement, gsd_save_summary.
+// Tests the three registered tools: gsd_decision_save, gsd_requirement_update, gsd_summary_save.
 // Each tool is tested via direct function invocation against an in-memory DB.
 
 import { createTestContext } from './test-helpers.ts';
@@ -50,10 +50,10 @@ function cleanupDir(dir: string): void {
  */
 
 // ═══════════════════════════════════════════════════════════════════════════
-// gsd_save_decision tool tests
+// gsd_decision_save tool tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── gsd_save_decision ──');
+console.log('\n── gsd_decision_save ──');
 
 {
   const tmpDir = makeTmpDir();
@@ -121,10 +121,10 @@ console.log('\n── gsd_save_decision ──');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// gsd_update_requirement tool tests
+// gsd_requirement_update tool tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── gsd_update_requirement ──');
+console.log('\n── gsd_requirement_update ──');
 
 {
   const tmpDir = makeTmpDir();
@@ -192,10 +192,10 @@ console.log('\n── gsd_update_requirement ──');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// gsd_save_summary tool tests
+// gsd_summary_save tool tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── gsd_save_summary ──');
+console.log('\n── gsd_summary_save ──');
 
 {
   const tmpDir = makeTmpDir();