@opengsd/gsd-pi 1.8.1-dev.897b3c90 → 1.9.0-dev.5c1a3ff2

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -17,6 +17,7 @@ import { getGateIdsForTurn } from "./gate-registry.js";
 import {
   KNOWN_PREFERENCE_KEYS,
   KNOWN_UNIT_LABELS,
+  CONFIGURABLE_PLANNING_SUBAGENT_UNITS,
   GSD_MODEL_PHASE_KEYS,
 
   SKILL_ACTIONS,
@@ -26,6 +27,10 @@ import {
   type GSDSkillRule,
   type GSDThinkingLevel,
 } from "./preferences-types.js";
+import {
+  ALLOWED_PLANNING_DISPATCH_AGENTS,
+  allowedPlanningDispatchAgentsList,
+} from "./planning-subagent-registry.js";
 
 const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 const VALID_THINKING_LEVELS = new Set<GSDThinkingLevel>([
@@ -747,6 +752,63 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Planning Subagents ─────────────────────────────────────────────────
+  if (preferences.planning_subagents !== undefined) {
+    if (
+      !preferences.planning_subagents ||
+      typeof preferences.planning_subagents !== "object" ||
+      Array.isArray(preferences.planning_subagents)
+    ) {
+      errors.push("planning_subagents must be an object keyed by planning unit type");
+    } else {
+      const validUnits = new Set<string>(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+      const validPlanningSubagents: NonNullable<GSDPreferences["planning_subagents"]> = {};
+
+      for (const [unitType, rawConfig] of Object.entries(preferences.planning_subagents as Record<string, unknown>)) {
+        if (!validUnits.has(unitType)) {
+          errors.push(
+            `planning_subagents unknown or unsupported unit "${unitType}" — supported units: ` +
+            `${CONFIGURABLE_PLANNING_SUBAGENT_UNITS.join(", ")}`,
+          );
+          continue;
+        }
+        if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
+          errors.push(`planning_subagents.${unitType} must be an object with an allowed array`);
+          continue;
+        }
+
+        const allowed = normalizeStringArray((rawConfig as Record<string, unknown>).allowed);
+        if (allowed.length === 0) {
+          errors.push(`planning_subagents.${unitType}.allowed must include at least one read-only planning specialist`);
+          continue;
+        }
+
+        const sanitizedAllowed: string[] = [];
+        for (const agentId of allowed) {
+          if (!ALLOWED_PLANNING_DISPATCH_AGENTS.has(agentId)) {
+            errors.push(
+              `planning_subagents.${unitType}.allowed includes "${agentId}", which is not classified as a ` +
+              `read-only planning specialist. Allowed agents: ${allowedPlanningDispatchAgentsList()}`,
+            );
+            continue;
+          }
+          sanitizedAllowed.push(agentId);
+        }
+
+        const dedupedAllowed = Array.from(new Set(sanitizedAllowed));
+        if (dedupedAllowed.length > 0) {
+          validPlanningSubagents[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>] = {
+            allowed: dedupedAllowed,
+          };
+        }
+      }
+
+      if (Object.keys(validPlanningSubagents).length > 0) {
+        validated.planning_subagents = validPlanningSubagents;
+      }
+    }
+  }
+
   // ─── Dynamic Routing ─────────────────────────────────────────────────
   if (preferences.dynamic_routing !== undefined) {
     if (typeof preferences.dynamic_routing === "object" && preferences.dynamic_routing !== null) {

package/src/resources/extensions/gsd/preferences.ts

@@ -817,6 +817,7 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
       : undefined,
     post_unit_hooks: mergePostUnitHooks(base.post_unit_hooks, override.post_unit_hooks),
     pre_dispatch_hooks: mergePreDispatchHooks(base.pre_dispatch_hooks, override.pre_dispatch_hooks),
+    planning_subagents: mergePlanningSubagents(base.planning_subagents, override.planning_subagents),
     dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
       ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) } as DynamicRoutingConfig
       : undefined,
@@ -943,6 +944,30 @@ function mergePreDispatchHooks(
   return merged.length > 0 ? merged : undefined;
 }
 
+function mergePlanningSubagents(
+  base?: GSDPreferences["planning_subagents"],
+  override?: GSDPreferences["planning_subagents"],
+): GSDPreferences["planning_subagents"] | undefined {
+  if (!base && !override) return undefined;
+  const merged: NonNullable<GSDPreferences["planning_subagents"]> = {};
+  const unitTypes = new Set([
+    ...Object.keys(base ?? {}),
+    ...Object.keys(override ?? {}),
+  ]);
+
+  for (const unitType of unitTypes) {
+    const allowed = mergeStringLists(
+      base?.[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>]?.allowed,
+      override?.[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>]?.allowed,
+    );
+    if (allowed?.length) {
+      merged[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>] = { allowed };
+    }
+  }
+
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
 // ─── System Prompt Rendering ──────────────────────────────────────────────────
 
 export function renderPreferencesForSystemPrompt(

package/src/resources/extensions/gsd/provider-payload-policy.ts

@@ -2,10 +2,12 @@
  * Provider Payload Policy - ordered shaping of provider request payloads.
  *
  * The order is intentional:
- * 1. observation budgeting masks old tool results in auto-mode,
- * 2. display truncation caps tool-result text for every mode,
- * 3. the protected Source Context Block is appended after truncation,
- * 4. supported models receive the configured service tier.
+ * 1. superseded GSD context injections (memory/guided/forensics) are removed,
+ *    keeping only the latest, for every mode,
+ * 2. observation budgeting masks old tool results in auto-mode,
+ * 3. display truncation caps tool-result text for every mode,
+ * 4. the protected Source Context Block is appended after truncation,
+ * 5. supported models receive the configured service tier.
  */
 
 import type { ContextManagementConfig } from "./preferences-types.js";
@@ -14,6 +16,8 @@ import type { ServiceTierSetting } from "./service-tier.js";
 import {
   createObservationMask,
   createResponsesInputObservationMask,
+  filterSupersededContextInjections,
+  filterSupersededResponsesContextInjections,
   truncateContextResultMessages,
   truncateResponsesInputResultItems,
 } from "./context-masker.js";
@@ -80,10 +84,20 @@ function applyContextManagement(
   deps: ProviderPayloadPolicyDeps,
 ): void {
   const config = deps.loadContextManagementConfig();
+  applyContextInjectionFilter(payload);
   applyObservationBudget(payload, config, deps.isAutoActive());
   applyDisplayTruncation(payload, config);
 }
 
+function applyContextInjectionFilter(payload: Record<string, unknown>): void {
+  if (Array.isArray(payload.messages)) {
+    payload.messages = filterSupersededContextInjections(payload.messages as MessagePayload);
+  }
+  if (Array.isArray(payload.input)) {
+    payload.input = filterSupersededResponsesContextInjections(payload.input as ResponsesInputPayload);
+  }
+}
+
 function applyObservationBudget(
   payload: Record<string, unknown>,
   config: ContextManagementConfig | undefined,

package/src/resources/extensions/gsd/safety/destructive-guard.ts

@@ -14,7 +14,7 @@ interface DestructivePattern {
 }
 
 const DESTRUCTIVE_PATTERNS: readonly DestructivePattern[] = [
-  { pattern: /\brm\s+(-[^\s]*[rfRF][^\s]*\s+|.*\s+-[^\s]*[rfRF])/, label: "recursive delete" },
+  { pattern: /\brm\s+((?:-(?!-)[^\s]*[rR][^\s]*|--recursive)\s+|.*\s+(?:-(?!-)[^\s]*[rR][^\s]*|--recursive)(?:\s|$))/, label: "recursive delete" },
   { pattern: /\bgit\s+push\s+.*--force/, label: "force push" },
   { pattern: /\bgit\s+push\s+-f\b/, label: "force push" },
   { pattern: /\bgit\s+reset\s+--hard/, label: "hard reset" },

package/src/resources/extensions/gsd/skill-activation.ts

@@ -131,10 +131,23 @@ function resolvePreferredSkillNames(
  *  to prevent prompt injection via crafted directory names. */
 const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
 
-function formatSkillActivationBlock(skillNames: string[]): string {
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function formatSkillActivationBlock(skillNames: string[], skillPaths: Map<string, string>): string {
   const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
   if (safe.length === 0) return "";
-  const reads = safe.map(name => `Read the installed '${name}' skill file from <available_skills>`).join(". ");
+  const reads = safe.map(name => {
+    const path = skillPaths.get(name);
+    if (path) return `Read the skill file at \`${escapeXml(path)}\``;
+    return `Find '${name}' in <available_skills>, copy its <location> value, and pass that exact path to read`;
+  }).join(". ");
   return `<skill_activation>${reads}.</skill_activation>`;
 }
 
@@ -203,6 +216,7 @@ export function buildSkillActivationBlock(params: {
   const visibleSkills = loaded;
   const manifestScopedSkills = filterSkillsByManifest(visibleSkills, params.unitType);
   const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
+  const installedSkillPaths = new Map(visibleSkills.map(skill => [normalizeSkillReference(skill.name), skill.filePath]));
   warnIfManifestHasMissingSkills(params.unitType, installedNames);
   const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
   const matched = new Set<string>();
@@ -252,7 +266,7 @@ export function buildSkillActivationBlock(params: {
   const ordered = [...matched]
     .filter(name => installedNames.has(name) && !avoided.has(name))
     .sort();
-  const activationBlock = formatSkillActivationBlock(ordered);
+  const activationBlock = formatSkillActivationBlock(ordered, installedSkillPaths);
 
   // Omit recommendations when the system catalog is manifest-scoped for this
   // unit — skill names are already listed in <available_skills>.

package/src/resources/extensions/gsd/templates/PREFERENCES.md

@@ -92,6 +92,11 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# planning_subagents:
+#   plan-milestone:
+#     allowed: [scout, planner, security]
+#   plan-slice:
+#     allowed: [scout, planner, reviewer, security]
 # language:
 # experimental:
 #   rtk: false

package/src/resources/extensions/gsd/tests/auto-artifact-paths.test.ts

@@ -442,11 +442,11 @@ test("bare milestone id still falls back to a lone team-suffix projection (#1195
 // ── #1208: flat-phase execute-task summaries resolve at the phase root ────────
 //
 // In flat-phase layout task summaries are written beside the plan files
-// (phases/<phase>/T##-SUMMARY.md), NOT under a tasks/ subdir. A tasks/ dir may
-// still exist to hold auxiliary task-scoped gate artifacts (e.g. T01-VERIFY.json).
+// (phases/<phase>/S##-T##-SUMMARY.md), NOT under a tasks/ subdir. A tasks/ dir
+// may still exist to hold auxiliary task-scoped gate artifacts (e.g. T01-VERIFY.json).
 // Before the fix, the mere existence of that tasks/ dir redirected summary
-// verification into tasks/T##-SUMMARY.md — which never exists — trapping auto-mode
-// in a false verification retry that eventually paused after a successful task.
+// verification into tasks/S##-T##-SUMMARY.md — which never exists — trapping
+// auto-mode in a false verification retry after a successful task.
 
 test("flat-phase execute-task summary resolves at phase root when no tasks/ dir exists (#1208)", () => {
   const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-flat-task-summary-")));
@@ -461,7 +461,7 @@ test("flat-phase execute-task summary resolves at phase root when no tasks/ dir
 
     assert.equal(
       resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root),
-      join(phaseDir, "T02-SUMMARY.md"),
+      join(phaseDir, "S03-T02-SUMMARY.md"),
     );
   } finally {
     _clearGsdRootCache();
@@ -489,12 +489,12 @@ test("flat-phase execute-task summary resolves at phase root even when tasks/ di
     const resolved = resolveExpectedArtifactPath("execute-task", "M049/S03/T02", root);
     assert.equal(
       resolved,
-      join(phaseDir, "T02-SUMMARY.md"),
+      join(phaseDir, "S03-T02-SUMMARY.md"),
       "flat-phase task summary must resolve at the phase root, not tasks/",
     );
     assert.notEqual(
       resolved,
-      join(tasksDir, "T02-SUMMARY.md"),
+      join(tasksDir, "S03-T02-SUMMARY.md"),
       "a tasks/ dir with gate artifacts must NOT redirect summary resolution into tasks/",
     );
   } finally {

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

@@ -1218,6 +1218,10 @@ test("hasImplementationArtifacts finds integration implementation-only commits w
 
     execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: base, stdio: "ignore" });
     writeIntegrationBranch(base, "M001", "main");
+    // ADR-045: writeIntegrationBranch no longer creates milestones/<MID>/ as a
+    // side effect (META is now flat at .gsd/<MID>-META.json), so scaffold the
+    // legacy summary dir explicitly.
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
     writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
     execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
     execFileSync("git", ["commit", "-m", "chore: auto-commit after complete-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
@@ -2063,6 +2067,41 @@ test("#1088: writeReactiveExecuteBlocker preserves deferred batch task statuses"
   }
 });
 
+test("#1343: writeReactiveExecuteBlocker uses slice-qualified summaries in flat-phase (no cross-slice collision)", () => {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  try {
+    // Flat-phase layout: slices S01 and S02 share the phase dir and reuse task
+    // id T03. Only the sibling slice S01 produced a summary.
+    const phaseDir = join(base, ".gsd", "phases", "01-test");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "01-01-PLAN.md"), "# S01: First\n", "utf-8");
+    writeFileSync(join(phaseDir, "01-02-PLAN.md"), "# S02: Second\n", "utf-8");
+    writeFileSync(join(phaseDir, "S01-T03-SUMMARY.md"), "# S01 T03 Summary\n", "utf-8");
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "pending" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+    insertTask({ id: "T03", milestoneId: "M001", sliceId: "S02", title: "Shared id", status: "pending" });
+
+    const recovery = writeReactiveExecuteBlocker(
+      "M001/S02/reactive+T03",
+      base,
+      "verification retries exhausted",
+    );
+
+    assert.ok(recovery, "recovery should run with DB available");
+    // S02 never wrote S02-T03-SUMMARY.md; the sibling S01-T03-SUMMARY.md must
+    // NOT make S02/T03 look complete. It has to be skipped.
+    assert.deepEqual(recovery!.completedTaskIds, []);
+    assert.deepEqual(recovery!.skippedTaskIds, ["T03"]);
+    assert.equal(getTask("M001", "S02", "T03")?.status, "skipped");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/before-provider-context-management.test.ts

@@ -143,3 +143,58 @@ test("successful shell result clears source context before provider injection",
   assert.equal(payload.messages.length, 1);
   assert.doesNotMatch(payload.messages[0].content[0].text, /Source Context Block/);
 });
+
+test("before_provider_request keeps only the latest GSD context injection across a 5-turn session", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-injections-"));
+  const gsdHome = join(dir, "home");
+  const project = join(dir, "project");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHome, { recursive: true });
+  process.env.GSD_HOME = gsdHome;
+  process.chdir(project);
+  _setAutoActiveForTest(false);
+
+  t.after(() => {
+    _setAutoActiveForTest(false);
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const beforeProviderRequest = requireHook(createHookHandlers(), "before_provider_request");
+
+  const sentinel = "[GSD Context Injection]";
+  const contextInjection = (turn: number) => ({
+    role: "user",
+    content: [{ type: "text", text: `${sentinel}\n[MEMORY] turn=${turn}` }],
+  });
+
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "turn 1" }] },
+      contextInjection(1),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      { role: "user", content: [{ type: "text", text: "turn 2" }] },
+      contextInjection(2),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      { role: "user", content: [{ type: "text", text: "turn 3" }] },
+      contextInjection(3),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      { role: "user", content: [{ type: "text", text: "turn 4" }] },
+      contextInjection(4),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+      { role: "user", content: [{ type: "text", text: "turn 5" }] },
+      contextInjection(5),
+    ],
+  };
+
+  await beforeProviderRequest({ payload });
+
+  const survivors = (payload.messages as any[]).filter((m) => (m.content?.[0]?.text ?? "").startsWith(sentinel));
+  assert.equal(survivors.length, 1);
+  assert.match(survivors[0].content[0].text, /turn=5/);
+});

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -23,6 +23,7 @@ import {
   SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteTask } from '../tools/complete-task.ts';
+import { resolveTaskFile } from '../paths.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
@@ -381,6 +382,80 @@ console.log('\n=== complete-task: handler happy path ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: Flat-phase duplicate task IDs are slice-qualified
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: flat-phase duplicate task IDs are slice-qualified ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-flat-task-summary-'));
+  const phaseDir = path.join(basePath, '.gsd', 'phases', '01-test');
+  fs.mkdirSync(phaseDir, { recursive: true });
+  fs.writeFileSync(path.join(phaseDir, '01-01-PLAN.md'), `# S01: First Slice
+
+## Tasks
+
+- [ ] **T03: Shared task id** \`est:30m\`
+  - Do: Complete first slice task
+  - Verify: Run first check
+`);
+  fs.writeFileSync(path.join(phaseDir, '01-02-PLAN.md'), `# S02: Second Slice
+
+## Tasks
+
+- [ ] **T03: Shared task id** \`est:30m\`
+  - Do: Complete second slice task
+  - Verify: Run second check
+`);
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First Slice', sequence: 1 });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second Slice', sequence: 2 });
+
+  const first = await handleCompleteTask({
+    ...makeValidParams(),
+    taskId: 'T03',
+    sliceId: 'S01',
+    oneLiner: 'Completed first slice T03',
+  }, basePath);
+  const second = await handleCompleteTask({
+    ...makeValidParams(),
+    taskId: 'T03',
+    sliceId: 'S02',
+    oneLiner: 'Completed second slice T03',
+  }, basePath);
+
+  assertTrue(!('error' in first), 'first duplicate task ID completion should succeed');
+  assertTrue(!('error' in second), 'second duplicate task ID completion should succeed');
+  if (!('error' in first) && !('error' in second)) {
+    const firstSummary = path.join(phaseDir, 'S01-T03-SUMMARY.md');
+    const secondSummary = path.join(phaseDir, 'S02-T03-SUMMARY.md');
+    const legacySummary = path.join(phaseDir, 'T03-SUMMARY.md');
+
+    assertEq(first.summaryPath, firstSummary, 'S01/T03 should write a slice-qualified summary path');
+    assertEq(second.summaryPath, secondSummary, 'S02/T03 should write a slice-qualified summary path');
+    assertTrue(fs.existsSync(firstSummary), 'S01/T03 summary should exist');
+    assertTrue(fs.existsSync(secondSummary), 'S02/T03 summary should exist');
+    assertTrue(!fs.existsSync(legacySummary), 'flat-phase completion should not create legacy T03-SUMMARY.md');
+
+    const firstContent = fs.readFileSync(firstSummary, 'utf-8');
+    const secondContent = fs.readFileSync(secondSummary, 'utf-8');
+    assertMatch(firstContent, /parent: S01/, 'S01/T03 summary should keep parent S01');
+    assertMatch(secondContent, /parent: S02/, 'S02/T03 summary should keep parent S02');
+    assertEq(resolveTaskFile(basePath, 'M001', 'S02', 'T03', 'SUMMARY'), secondSummary, 'resolver should prefer S02-specific summary');
+
+    const legacyFallback = path.join(phaseDir, 'T99-SUMMARY.md');
+    fs.writeFileSync(legacyFallback, '# Legacy task summary\n');
+    assertEq(resolveTaskFile(basePath, 'M001', 'S09', 'T99', 'SUMMARY'), legacyFallback, 'resolver should fall back to old flat summary names');
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Projection failure rolls DB completion back
 // ═══════════════════════════════════════════════════════════════════════════
@@ -416,7 +491,7 @@ console.log('\n=== complete-task: projection failure rolls DB completion back ==
   ).all();
   assertEq(evRows.length, 0, 'verification evidence should be deleted when projection rollback runs');
 
-  const summaryPath = path.join(path.dirname(planPath), 'T01-SUMMARY.md');
+  const summaryPath = path.join(path.dirname(planPath), 'S01-T01-SUMMARY.md');
   assertTrue(!fs.existsSync(summaryPath), 'SUMMARY.md should be removed so disk state stays pending');
 
   cleanupDir(basePath);