@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/workflow-authority-projection-conflict.test.ts

@@ -0,0 +1,177 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { queryDecisionsFromMemories, queryRequirements } from "../context-store.ts";
+import { deriveStateFromDb } from "../state.ts";
+import {
+  createWorkflowAuthorityFixture,
+  type WorkflowAuthorityFixture,
+} from "./workflow-authority-fixture.ts";
+
+function writeProjection(root: string, path: string, content: string): void {
+  const fullPath = join(root, ".gsd", path);
+  mkdirSync(dirname(fullPath), { recursive: true });
+  writeFileSync(fullPath, content, "utf8");
+}
+
+function writeContradictoryProjections(root: string): void {
+  writeProjection(
+    root,
+    "STATE.md",
+    [
+      "# GSD State",
+      "",
+      "**Active Milestone:** M999",
+      "**Active Slice:** S99",
+      "**Phase:** complete",
+      "**Requirements Status:** 0 active · 1 validated",
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "PROJECT.md",
+    [
+      "# Projection-only project",
+      "",
+      "## Milestone Sequence",
+      "- [x] M001: Falsely complete",
+      "- [ ] M999: Projection-only active milestone",
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "REQUIREMENTS.md",
+    [
+      "# Requirements",
+      "",
+      "## Validated",
+      "### R999 — Markdown controls workflow state",
+      "- Status: validated",
+      "- Primary owning slice: M999/S99",
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "DECISIONS.md",
+    [
+      "# Decisions Register",
+      "",
+      "| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |",
+      "|---|------|-------|----------|--------|-----------|------------|---------|",
+      "| D999 | M999/S99 | architecture | Choose authority | Markdown is authoritative | projection conflict | No | human |",
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "milestones/M001/M001-ROADMAP.md",
+    [
+      "# M001: Falsely complete",
+      "",
+      "## Slices",
+      "- [ ] **S01: Falsely reopened** `risk:low` `depends:[]`",
+      "- [x] **S02: Falsely complete** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "milestones/M001/slices/S02/S02-PLAN.md",
+    [
+      "# S02: Falsely complete",
+      "",
+      "## Tasks",
+      "- [x] **T99: Projection-only task** `est:1m`",
+    ].join("\n"),
+  );
+}
+
+async function readDirectDbAuthoritySnapshot(fixture: WorkflowAuthorityFixture) {
+  const state = await deriveStateFromDb(fixture.root);
+  return {
+    state: {
+      phase: state.phase,
+      milestone: state.activeMilestone?.id ?? null,
+      slice: state.activeSlice?.id ?? null,
+      task: state.activeTask?.id ?? null,
+      requirements: state.requirements,
+    },
+    registry: state.registry.map((milestone) => ({
+      id: milestone.id,
+      status: milestone.status,
+    })),
+    slices: getMilestoneSlices(fixture.ids.milestone).map((slice) => ({
+      id: slice.id,
+      status: slice.status,
+      depends: slice.depends,
+    })),
+    tasks: {
+      completed: getSliceTasks(fixture.ids.milestone, fixture.ids.completedSlice).map((task) => ({
+        id: task.id,
+        status: task.status,
+      })),
+      ready: getSliceTasks(fixture.ids.milestone, fixture.ids.readySlice).map((task) => ({
+        id: task.id,
+        status: task.status,
+      })),
+    },
+    requirements: queryRequirements({
+      milestoneId: fixture.ids.milestone,
+      sliceId: fixture.ids.readySlice,
+    }).map((requirement) => ({
+      id: requirement.id,
+      status: requirement.status,
+      owner: requirement.primary_owner,
+    })),
+    decisions: queryDecisionsFromMemories().map((decision) => ({
+      id: decision.id,
+      choice: decision.choice,
+    })),
+  };
+}
+
+test("direct DB authority queries ignore contradictory Markdown projections", async (t) => {
+  const fixture = await createWorkflowAuthorityFixture();
+  t.after(() => fixture.cleanup());
+  fixture.reopen();
+  const before = await readDirectDbAuthoritySnapshot(fixture);
+
+  assert.deepEqual(before, {
+    state: {
+      phase: "executing",
+      milestone: fixture.ids.milestone,
+      slice: fixture.ids.readySlice,
+      task: fixture.ids.readyTask,
+      requirements: {
+        active: 1,
+        validated: 0,
+        deferred: 0,
+        outOfScope: 0,
+        blocked: 0,
+        total: 1,
+      },
+    },
+    registry: [{ id: fixture.ids.milestone, status: "active" }],
+    slices: [
+      { id: fixture.ids.completedSlice, status: "complete", depends: [] },
+      { id: fixture.ids.readySlice, status: "pending", depends: [fixture.ids.completedSlice] },
+    ],
+    tasks: {
+      completed: [{ id: fixture.ids.completedTask, status: "complete" }],
+      ready: [{ id: fixture.ids.readyTask, status: "pending" }],
+    },
+    requirements: [
+      { id: fixture.ids.requirement, status: "active", owner: "M001/S02" },
+    ],
+    decisions: [
+      { id: fixture.ids.decision, choice: "SQLite is authoritative" },
+    ],
+  });
+
+  writeContradictoryProjections(fixture.root);
+  fixture.reopen();
+
+  const after = await readDirectDbAuthoritySnapshot(fixture);
+  assert.deepEqual(after, before);
+});

package/src/resources/extensions/gsd/tests/workflow-fault-harness.test.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createWorkflowFaultHarness,
+  type WorkflowFaultPoint,
+} from "./workflow-fault-harness.js";
+
+test("fault harness throws once at the armed named boundary", () => {
+  const harness = createWorkflowFaultHarness("after-db-commit-before-render");
+
+  harness.hit("before-transaction-commit", "complete-task");
+  assert.throws(
+    () => harness.hit("after-db-commit-before-render", "complete-task"),
+    /complete-task.*after-db-commit-before-render.*hit 1/,
+  );
+
+  assert.equal(harness.count("before-transaction-commit"), 1);
+  assert.equal(harness.count("after-db-commit-before-render"), 1);
+});
+
+test("fault harness automatically disarms after its first matching hit", () => {
+  const point: WorkflowFaultPoint = "during-projection-write";
+  const harness = createWorkflowFaultHarness(point);
+
+  assert.throws(() => harness.hit(point, "complete-slice"));
+  assert.doesNotThrow(() => harness.hit(point, "complete-slice"));
+  assert.equal(harness.count(point), 2);
+});
+
+test("fault harness instances never share armed state or counts", () => {
+  const first = createWorkflowFaultHarness("before-independent-reopen");
+  const second = createWorkflowFaultHarness("before-independent-reopen");
+
+  assert.throws(() => first.hit("before-independent-reopen", "resume"));
+  assert.equal(first.count("before-independent-reopen"), 1);
+  assert.equal(second.count("before-independent-reopen"), 0);
+  assert.throws(() => second.hit("before-independent-reopen", "resume"));
+});

package/src/resources/extensions/gsd/tests/workflow-fault-harness.ts

@@ -0,0 +1,72 @@
+import { mkdirSync } from "node:fs";
+
+import { getDb } from "../gsd-db.js";
+
+export type WorkflowFaultPoint =
+  | "before-transaction-commit"
+  | "after-db-commit-before-render"
+  | "during-projection-write"
+  | "before-independent-reopen"
+  | "after-independent-reopen";
+
+export interface WorkflowFaultHarness {
+  hit(point: WorkflowFaultPoint, operation?: string): void;
+  count(point: WorkflowFaultPoint): number;
+  armDatabaseAbort(
+    column: "status" | "full_summary_md",
+    predicate:
+      | "NEW.status = 'complete' AND OLD.status <> 'complete'"
+      | "NEW.full_summary_md IS NOT OLD.full_summary_md",
+  ): void;
+  obstructProjection(path: string): void;
+}
+
+export class WorkflowFaultError extends Error {
+  readonly point: WorkflowFaultPoint;
+  readonly operation: string;
+  readonly hitCount: number;
+
+  constructor(point: WorkflowFaultPoint, operation: string, hitCount: number) {
+    super(`${operation} fault at ${point} (hit ${hitCount})`);
+    this.name = "WorkflowFaultError";
+    this.point = point;
+    this.operation = operation;
+    this.hitCount = hitCount;
+  }
+}
+
+export function createWorkflowFaultHarness(
+  armedPoint: WorkflowFaultPoint,
+): WorkflowFaultHarness {
+  const counts = new Map<WorkflowFaultPoint, number>();
+  let armed = true;
+
+  return {
+    hit(point, operation = "workflow-operation") {
+      const hitCount = (counts.get(point) ?? 0) + 1;
+      counts.set(point, hitCount);
+      if (armed && point === armedPoint) {
+        armed = false;
+        throw new WorkflowFaultError(point, operation, hitCount);
+      }
+    },
+    count(point) {
+      return counts.get(point) ?? 0;
+    },
+    armDatabaseAbort(column, predicate) {
+      const triggerName = `workflow_fault_${armedPoint.replaceAll("-", "_")}`;
+      const message = `complete-dependent-slice fault at ${armedPoint}`;
+      getDb().exec(`
+        CREATE TEMP TRIGGER ${triggerName}
+        BEFORE UPDATE OF ${column} ON slices
+        WHEN ${predicate}
+        BEGIN
+          SELECT RAISE(ABORT, '${message}');
+        END
+      `);
+    },
+    obstructProjection(path) {
+      mkdirSync(path, { recursive: true });
+    },
+  };
+}

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -352,7 +352,7 @@ test('workflow-projections: regenerateIfMissing SUMMARY is idempotent for flat-p
       keyDecisions: ['Use centralized task summary paths.'],
     });
 
-    const summaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    const summaryPath = join(phaseDir, 'S01-T01-SUMMARY.md');
     assert.ok(!existsSync(summaryPath), 'precondition: flat-phase task summary absent');
 
     const first = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
@@ -399,7 +399,7 @@ test('workflow-projections: flat-phase SUMMARY regeneration ignores stale nested
       status: 'complete',
     });
 
-    const rootSummaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    const rootSummaryPath = join(phaseDir, 'S01-T01-SUMMARY.md');
     assert.ok(!existsSync(rootSummaryPath), 'precondition: canonical flat-phase task summary absent');
 
     const regenerated = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
@@ -440,8 +440,8 @@ test('workflow-projections: renderSummaryProjection uses milestone title when cr
       status: 'complete',
     });
 
-    const titleSummaryPath = join(base, '.gsd', 'phases', '01-milestone', 'T01-SUMMARY.md');
-    const idSummaryPath = join(base, '.gsd', 'phases', '01-m001', 'T01-SUMMARY.md');
+    const titleSummaryPath = join(base, '.gsd', 'phases', '01-milestone', 'S01-T01-SUMMARY.md');
+    const idSummaryPath = join(base, '.gsd', 'phases', '01-m001', 'S01-T01-SUMMARY.md');
 
     renderSummaryProjection(base, 'M001', 'S01', 'T01');
 

package/src/resources/extensions/gsd/tests/worktree-state-projection.test.ts

@@ -117,8 +117,8 @@ test("projectRootToWorktree projects flat-phase discuss artifacts before dispatc
     new WorktreeStateProjection().projectRootToWorktree(scope);
 
     assert.ok(
-      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-META.json")),
-      "milestone metadata is projected into the worktree",
+      !existsSync(join(worktree, ".gsd", "milestones")),
+      "stale metadata-only legacy milestones/ scaffold is not projected into the worktree",
     );
     assert.ok(
       existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-CONTEXT.md")),

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -246,6 +246,66 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
+  // ─── 7b. flat-phase sync skips empty legacy milestones root ───────────
+  console.log('\n=== 7b. flat-phase sync skips empty legacy milestones root ===');
+  {
+    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-main-'));
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-wt-'));
+
+    try {
+      const phaseDir = join(mainBase, '.gsd', 'phases', '01-foundation');
+      mkdirSync(phaseDir, { recursive: true });
+      mkdirSync(join(mainBase, '.gsd', 'milestones'), { recursive: true });
+      mkdirSync(join(wtBase, '.gsd'), { recursive: true });
+      writeFileSync(join(phaseDir, '01-CONTEXT.md'), '# Foundation\n');
+
+      syncGsdStateToWorktree(mainBase, wtBase);
+
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'phases', '01-foundation', '01-CONTEXT.md')),
+        'flat-phase artifact is synced to worktree',
+      );
+      assert.ok(
+        !existsSync(join(wtBase, '.gsd', 'milestones')),
+        'empty legacy milestones/ root is not recreated in worktree',
+      );
+    } finally {
+      rmSync(mainBase, { recursive: true, force: true });
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 7c. flat-phase sync skips metadata-only legacy milestone dirs ────
+  console.log('\n=== 7c. flat-phase sync skips metadata-only legacy milestone dirs ===');
+  {
+    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-meta-main-'));
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-meta-wt-'));
+
+    try {
+      const phaseDir = join(mainBase, '.gsd', 'phases', '01-foundation');
+      const metaDir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(phaseDir, { recursive: true });
+      mkdirSync(metaDir, { recursive: true });
+      mkdirSync(join(wtBase, '.gsd'), { recursive: true });
+      writeFileSync(join(phaseDir, '01-CONTEXT.md'), '# Foundation\n');
+      writeFileSync(join(metaDir, 'M001-META.json'), '{"integrationBranch":"main"}\n');
+
+      syncGsdStateToWorktree(mainBase, wtBase);
+
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'phases', '01-foundation', '01-CONTEXT.md')),
+        'flat-phase artifact is synced to worktree',
+      );
+      assert.ok(
+        !existsSync(join(wtBase, '.gsd', 'milestones')),
+        'metadata-only legacy milestones/ scaffold is not recreated in worktree',
+      );
+    } finally {
+      rmSync(mainBase, { recursive: true, force: true });
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
   // ─── 8. syncWorktreeStateBack does not copy task projections ───────────
   console.log('\n=== 8. syncWorktreeStateBack leaves task projections in worktree ===');
   {

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -7,12 +7,16 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, sep } from 'node:path';
 
 import { GSD_PHASE_SCOPE_DISPLAY_REASON, GSD_SECTION_CLOSE_GATE_DISPLAY_REASON } from '../auto-unit-tool-scope.ts';
 import { ALLOWED_PLANNING_DISPATCH_AGENTS, shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
 import { extractSubagentAgentClasses } from '../bootstrap/subagent-input.ts';
 import { isDeterministicPolicyError } from '../auto-tool-tracking.ts';
+import { clearGSDPreferencesCache, getProjectGSDPreferencesPath, loadEffectiveGSDPreferences } from '../preferences.ts';
+import { applyPlanningSubagentPreferences } from '../planning-subagent-policy.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
 const BASE = join('/tmp', 'fake-project');
@@ -335,6 +339,76 @@ test('planning-dispatch: still allows writes inside .gsd/', () => {
   assert.strictEqual(r.block, false);
 });
 
+test('planning_subagents: upgrades plan-milestone to controlled read-only dispatch', () => {
+  const policy = applyPlanningSubagentPreferences('plan-milestone', PLANNING, {
+    planning_subagents: {
+      'plan-milestone': { allowed: ['security'] },
+    },
+  });
+  const allowed = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-milestone', policy, ['security']);
+  assert.strictEqual(allowed.block, false);
+
+  const blocked = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-milestone', policy, ['reviewer']);
+  assert.strictEqual(blocked.block, true);
+  assert.match(blocked.reason!, /planning_subagents/);
+  assert.match(blocked.reason!, /permitted agents for this unit: security/);
+});
+
+test('planning_subagents: widens plan-slice manifest allowlist without allowing unsafe agents', () => {
+  const policy = applyPlanningSubagentPreferences('plan-slice', {
+    mode: 'planning-dispatch',
+    allowedSubagents: ['scout', 'planner'],
+  }, {
+    planning_subagents: {
+      'plan-slice': { allowed: ['security'] },
+    },
+  });
+
+  const added = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', policy, ['security']);
+  assert.strictEqual(added.block, false);
+
+  const unsafe = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', policy, ['worker']);
+  assert.strictEqual(unsafe.block, true);
+  assert.match(unsafe.reason!, /read-only specialists/);
+});
+
+test('planning_subagents: registered custom planning agents pass runtime read-only registry', (t) => {
+  const tempProject = mkdtempSync(join(tmpdir(), 'gsd-custom-planning-agent-'));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, '.gsd'), { recursive: true });
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      '---',
+      'version: 1',
+      'planning_subagent_registry:',
+      '  my-custom-planner:',
+      '    read_only_specialist: true',
+      'planning_subagents:',
+      '  plan-slice:',
+      '    allowed: [my-custom-planner]',
+      '---',
+      '',
+    ].join('\n'),
+    'utf-8',
+  );
+  clearGSDPreferencesCache();
+
+  const preferences = loadEffectiveGSDPreferences(tempProject)?.preferences;
+  const policy = applyPlanningSubagentPreferences('plan-slice', PLANNING_DISPATCH, preferences);
+  const custom = shouldBlockPlanningUnit('subagent', '', tempProject, 'plan-slice', policy, ['my-custom-planner']);
+  assert.strictEqual(custom.block, false, custom.reason);
+
+  const unregistered = shouldBlockPlanningUnit('subagent', '', tempProject, 'plan-slice', policy, ['other-planner']);
+  assert.strictEqual(unregistered.block, true);
+  assert.match(unregistered.reason!, /read-only specialists/);
+});
+
 // ─── planning mode: pass-through tools ────────────────────────────────────
 
 test('planning-unit: allows read tool', () => {

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -36,7 +36,15 @@ import {
 } from "../gsd-db.js";
 import { getWorkflowDatabasePath, ensureWorkflowDbAtPath } from "../db-workspace.js";
 import { getGatesForTurn } from "../gate-registry.js";
-import { gsdProjectionRoot, clearPathCache, resolveMilestonePath, resolveSlicePath } from "../paths.js";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  gsdProjectionRoot,
+  clearPathCache,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveSlicePath,
+} from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -89,13 +97,20 @@ function taskSummaryPath(
   // a legacy layout and breaks all subsequent path resolution for the session.
   const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
   const phaseDir = resolveMilestonePath(basePath, milestoneId);
-  if (slicePath && phaseDir && slicePath !== phaseDir) {
-    // Legacy layout: the slice has its own slices/SID/ subdir → tasks/ subdir
-    return join(slicePath, "tasks", `${taskId}-SUMMARY.md`);
+  const legacyBase = legacyMilestonesDir(basePath);
+  const isLegacy = phaseDir
+    ? phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\")
+    : false;
+  if (isLegacy && phaseDir) {
+    // Legacy layout: the slice has its own slices/SID/ subdir → tasks/ subdir.
+    const legacySlicePath = slicePath && slicePath !== phaseDir
+      ? slicePath
+      : join(phaseDir, "slices", sliceId);
+    return join(legacySlicePath, "tasks", buildTaskFileName(taskId, "SUMMARY"));
   }
   if (phaseDir) {
     // Flat-phase: task summaries go in the phase dir (no tasks/ subdir)
-    return join(phaseDir, `${taskId}-SUMMARY.md`);
+    return join(phaseDir, buildFlatTaskFileName(sliceId, taskId, "SUMMARY"));
   }
   // Fallback: legacy hardcoded path (milestone/slice dir not on disk yet)
   return join(

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -20,7 +20,7 @@ import {
 } from "../gsd-db.js";
 import type { GateEvaluationConfig, GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanFromDb } from "../markdown-renderer.js";
+import { renderPlanCheckboxes, renderPlanFromDb } from "../markdown-renderer.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -469,9 +469,13 @@ export async function handlePlanSlice(
     }
 
     const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+    const hasClosedTasks = sliceTasks.some((task) => isClosedStatus(task.status));
     const renderResult = sliceTasks.length === 0
       ? { planPath: "", taskPlanPaths: [] as string[] }
       : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+    if (sliceTasks.length > 0 && hasClosedTasks) {
+      await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
+    }
     if (sliceTasks.length > 0) {
       setSliceSketchFlag(params.milestoneId, params.sliceId, false);
     }

package/src/resources/extensions/gsd/tools/reopen-milestone.ts

@@ -22,7 +22,15 @@ import { logWarning } from "../workflow-logger.js";
 import { debugLog } from "../debug-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, clearPathCache } from "../paths.js";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveSlicePath,
+  resolveTasksDir,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenMilestoneParams {
   milestoneId: string;
@@ -69,6 +77,10 @@ export async function handleReopenMilestone(
   // auto-corrects entities back to "complete", making reopen a no-op (#3161).
   try {
     const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = !!milestoneDir && (
+      milestoneDir.startsWith(legacyBase + "/") || milestoneDir.startsWith(legacyBase + "\\")
+    );
     if (milestoneDir) {
       const milestoneSummary = join(milestoneDir, `${params.milestoneId}-SUMMARY.md`);
       if (existsSync(milestoneSummary)) unlinkSync(milestoneSummary);
@@ -85,10 +97,17 @@ export async function handleReopenMilestone(
       }
 
       const tasksDir = resolveTasksDir(basePath, params.milestoneId, slice.id);
-      if (tasksDir) {
-        const tasks = getSliceTasks(params.milestoneId, slice.id);
-        for (const task of tasks) {
-          const taskSummary = join(tasksDir, `${task.id}-SUMMARY.md`);
+      const tasks = getSliceTasks(params.milestoneId, slice.id);
+      for (const task of tasks) {
+        const taskSummaries = isLegacy
+          ? (tasksDir ? [join(tasksDir, buildTaskFileName(task.id, "SUMMARY"))] : [])
+          : milestoneDir
+            ? [
+              join(milestoneDir, buildFlatTaskFileName(slice.id, task.id, "SUMMARY")),
+              join(milestoneDir, buildTaskFileName(task.id, "SUMMARY")),
+            ]
+            : [];
+        for (const taskSummary of taskSummaries) {
           if (existsSync(taskSummary)) unlinkSync(taskSummary);
         }
       }

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -27,7 +27,15 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveTasksDir,
+  resolveSlicePath,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenSliceParams {
   milestoneId: string;
@@ -80,11 +88,23 @@ export async function handleReopenSlice(
   // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
   // auto-corrects tasks back to "complete", making reopen a no-op (#3161).
   try {
+    const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = !!milestoneDir && (
+      milestoneDir.startsWith(legacyBase + "/") || milestoneDir.startsWith(legacyBase + "\\")
+    );
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-    if (tasksDir) {
-      const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-      for (const task of tasks) {
-        const summaryPath = join(tasksDir, `${task.id}-SUMMARY.md`);
+    const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+    for (const task of tasks) {
+      const summaryPaths = isLegacy
+        ? (tasksDir ? [join(tasksDir, buildTaskFileName(task.id, "SUMMARY"))] : [])
+        : milestoneDir
+          ? [
+            join(milestoneDir, buildFlatTaskFileName(params.sliceId, task.id, "SUMMARY")),
+            join(milestoneDir, buildTaskFileName(task.id, "SUMMARY")),
+          ]
+          : [];
+      for (const summaryPath of summaryPaths) {
         if (existsSync(summaryPath)) unlinkSync(summaryPath);
       }
     }