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

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

@@ -97,6 +97,42 @@ test("projectRootToWorktree forwards root PROJECT.md into isolated worktrees", (
   }
 });
 
+test("projectRootToWorktree projects flat-phase discuss artifacts before dispatch", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const worktree = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktree, ".gsd", "phases", "01-foundation"), { recursive: true });
+
+    const projectPhaseDir = join(dir, ".gsd", "phases", "01-foundation");
+    mkdirSync(projectPhaseDir, { recursive: true });
+    writeFileSync(join(projectPhaseDir, "01-CONTEXT.md"), "# M001 Context\n");
+    writeFileSync(join(projectPhaseDir, "01-DISCUSSION.md"), "# M001 Discussion\n");
+
+    const metaDir = join(dir, ".gsd", "milestones", "M001");
+    mkdirSync(metaDir, { recursive: true });
+    writeFileSync(join(metaDir, "M001-META.json"), '{"branch":"milestone/M001"}');
+
+    const workspace = createWorkspace(worktree);
+    const scope = scopeMilestone(workspace, "M001");
+    new WorktreeStateProjection().projectRootToWorktree(scope);
+
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-META.json")),
+      "milestone metadata is projected into the worktree",
+    );
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-CONTEXT.md")),
+      "flat-phase CONTEXT.md is projected into the worktree",
+    );
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-DISCUSSION.md")),
+      "flat-phase DISCUSSION.md is projected into the worktree",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 test("projectRootToWorktree projects prior-milestone slice/task SUMMARY.md, not just top-level files", () => {
   // Regression: a worktree opened for the CURRENT milestone (M002) must also
   // receive the full subtree of OTHER, already-completed milestones (M001) so

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

@@ -13,6 +13,7 @@ import { GSD_PHASE_SCOPE_DISPLAY_REASON, GSD_SECTION_CLOSE_GATE_DISPLAY_REASON }
 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 { applyPlanningSubagentPreferences } from '../planning-subagent-policy.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
 const BASE = join('/tmp', 'fake-project');
@@ -335,6 +336,39 @@ 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/);
+});
+
 // ─── planning mode: pass-through tools ────────────────────────────────────
 
 test('planning-unit: allows read tool', () => {

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

@@ -26,6 +26,7 @@ import { tmpdir } from "node:os";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import {
+  _setWriteGateInterleaveHookForTest,
   childWriteGateAdapter,
   clearDiscussionFlowState,
   getPendingGate,
@@ -36,6 +37,9 @@ import {
   setPendingGate,
   type WriteGateSnapshot,
 } from "../bootstrap/write-gate.ts";
+import { acquireSyncLock, releaseSyncLock } from "../sync-lock.ts";
+
+const WRITE_GATE_LOCK_NAME = "write-gate.lock";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -356,3 +360,51 @@ test("seam: mutateWriteGateState reset path drops stale pendingGateId on a corru
   assert.equal(persisted.pendingGateId, null, "stale pending id must not be persisted after a corrupt-snapshot reconcile");
   assert.deepEqual(persisted.verifiedDepthMilestones, ["M099"]);
 });
+
+// ── (f) cross-process lock closes the read-merge-write lost-update window ────
+
+test("seam: read-merge-write holds the write-gate lock across the whole critical section", (t) => {
+  const dir = makeTempDir("lock-held");
+  t.after(() => {
+    _setWriteGateInterleaveHookForTest(null);
+    cleanup(dir);
+  });
+
+  // Fire inside the host's critical section, standing in for the OTHER process
+  // attempting to enter its own read-merge-write. The lock must lock it out.
+  let peerAcquiredMidSection: boolean | null = null;
+  _setWriteGateInterleaveHookForTest((lockRoot) => {
+    const res = acquireSyncLock(lockRoot, 0, WRITE_GATE_LOCK_NAME);
+    peerAcquiredMidSection = res.acquired;
+    if (res.acquired) releaseSyncLock(lockRoot, WRITE_GATE_LOCK_NAME);
+  });
+
+  markDepthVerified("M001", dir);
+
+  assert.equal(
+    peerAcquiredMidSection,
+    false,
+    "a concurrent process must be locked out of the read-merge-write section — this is what prevents the lost-update",
+  );
+  // The lock is released after the mutation, and the mutation still took effect.
+  assert.ok(loadWriteGateSnapshot(dir).verifiedDepthMilestones.includes("M001"));
+  assert.equal(acquireSyncLock(dir, 0, WRITE_GATE_LOCK_NAME).acquired, true, "lock released after mutation");
+  releaseSyncLock(dir, WRITE_GATE_LOCK_NAME);
+});
+
+test("seam: gate mutation fails OPEN when a live peer holds the lock (never blocks/refuses)", (t) => {
+  const dir = makeTempDir("lock-fail-open");
+  t.after(() => cleanup(dir));
+
+  // A live peer holds the lock (its own PID → never stolen as stale).
+  assert.equal(acquireSyncLock(dir, 0, WRITE_GATE_LOCK_NAME).acquired, true);
+  try {
+    // Host arms a gate while contended: fail-open means it proceeds anyway.
+    const armed = setPendingGate(GATE, dir);
+    assert.equal(armed, true, "arm must succeed (fail-open) even though the lock is held");
+    assert.equal(getPendingGate(dir), GATE);
+    assert.equal(readDiskRaw(dir).pendingGateId, GATE, "fail-open still persists the mutation");
+  } finally {
+    releaseSyncLock(dir, WRITE_GATE_LOCK_NAME);
+  }
+});

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

@@ -29,10 +29,22 @@ import {
   deleteVerificationEvidence,
   saveGateResult,
   getPendingGatesForTurn,
+  getUnresolvedBlockingReworkFindingsForTask,
+  getBlockingReworkFindingsForTask,
+  applyReworkResolutions,
+  type ReworkFindingStatus,
 } 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";
@@ -85,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(
@@ -185,6 +204,70 @@ export function normalizeListParam(value: unknown): string[] {
  * Build a TaskRow-shaped object from CompleteTaskParams so the unified
  * renderSummaryContent() can be used at completion time (#2720).
  */
+
+function normalizeReworkResolution(params: CompleteTaskParams): Array<{
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+  findingId: string;
+  status: "resolved" | "deferred-with-override";
+  evidence: string;
+  decisionRef?: string;
+}> {
+  return (params.reworkResolution ?? []).map((resolution) => ({
+    milestoneId: params.milestoneId,
+    sliceId: params.sliceId,
+    taskId: params.taskId,
+    findingId: resolution.findingId,
+    status: resolution.status,
+    evidence: resolution.evidence,
+    decisionRef: resolution.decisionRef,
+  }));
+}
+
+function unresolvedReworkError(missingFindingIds: string[]): string {
+  const plural = missingFindingIds.length === 1 ? "finding" : "findings";
+  return `unresolved blocking rework ${plural}: ${missingFindingIds.join(", ")} — provide reworkResolution entries with status resolved and evidence, or status deferred-with-override with evidence and decisionRef, before completing the task`;
+}
+
+function satisfiesBlockingReworkFinding(resolution: ReturnType<typeof normalizeReworkResolution>[number]): boolean {
+  if (resolution.evidence.trim().length === 0) return false;
+  if (resolution.status === "resolved") return true;
+  return (resolution.decisionRef ?? "").trim().length > 0;
+}
+
+/**
+ * Snapshot of a rework finding's status/evidence as it existed *before* this
+ * completion applied its reworkResolution. Captured inside the completion
+ * transaction so the compensating rollback paths can restore the exact prior
+ * state.
+ */
+type ReworkFindingSnapshot = {
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+  findingId: string;
+  status: ReworkFindingStatus;
+  evidence: string;
+  decisionRef?: string;
+};
+
+/**
+ * Restore rework findings to their pre-completion state.
+ *
+ * The completion transaction flips blocking findings to resolved/
+ * deferred-with-override via applyReworkResolutions. When a later projection
+ * or escalation write fails and we compensate by reverting the task to
+ * `pending`, we must also revert those findings. Otherwise a retry sees no
+ * unresolved blocking findings (getUnresolvedBlockingReworkFindingsForTask
+ * only returns `pending` rows) and completes the task with the blocking gate
+ * silently skipped.
+ */
+function revertAppliedReworkResolutions(snapshot: ReworkFindingSnapshot[]): void {
+  if (snapshot.length === 0) return;
+  applyReworkResolutions(snapshot);
+}
+
 function paramsToTaskRow(params: CompleteTaskParams, completedAt: string): TaskRow {
   return {
     milestone_id: params.milestoneId,
@@ -271,6 +354,7 @@ export async function handleCompleteTask(
   let guardError: string | null = null;
   let summaryMd = "";
   let repairTaskSummaryRow: TaskRow | null = null;
+  let appliedReworkSnapshot: ReworkFindingSnapshot[] = [];
   const rollbackDbPath = getWorkflowDatabasePath();
 
   // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
@@ -282,6 +366,8 @@ export async function handleCompleteTask(
   // no escalation recorded, and the loop would silently advance past it.
   // The filesystem write happens later (after side effects) because that's
   // the cheapest ordering and validation is where 99% of failures live.
+  const reworkResolutions = normalizeReworkResolution(params);
+
   let validatedEscalationArtifact: ReturnType<typeof buildEscalationArtifact> | null = null;
   let escalationWriteEnabled = false;
   if (params.escalation) {
@@ -323,6 +409,20 @@ export async function handleCompleteTask(
     }
 
     const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
+    const unresolvedRework = getUnresolvedBlockingReworkFindingsForTask(params.milestoneId, params.sliceId, params.taskId);
+    const resolvedFindingIds = new Set(
+      reworkResolutions
+        .filter(satisfiesBlockingReworkFinding)
+        .map((resolution) => resolution.findingId),
+    );
+    const missingFindingIds = unresolvedRework
+      .filter((finding) => !resolvedFindingIds.has(finding.finding_id))
+      .map((finding) => finding.finding_id);
+    if (missingFindingIds.length > 0) {
+      guardError = unresolvedReworkError(missingFindingIds);
+      return;
+    }
+
     if (existingTask && isClosedStatus(existingTask.status)) {
       // Stale-turn path: a timed-out turn that was superseded by recovery
       // can still reach this code when its LLM call eventually returns and
@@ -378,6 +478,38 @@ export async function handleCompleteTask(
       fullSummaryMd: summaryMd,
     });
 
+    // Only persist resolutions that actually satisfy the evidence
+    // requirement. The guard above admits a finding as long as ONE satisfying
+    // entry exists, but applyReworkResolutions writes by findingId and lets the
+    // last entry win. Persisting every entry would let a later non-satisfying
+    // duplicate (empty evidence, or deferred-with-override without decisionRef)
+    // overwrite a valid resolution and leave the finding non-pending without
+    // acceptable evidence. Filtering with the same predicate the guard uses
+    // keeps the applied set and the gate consistent.
+    const resolutionsToApply = reworkResolutions.filter(satisfiesBlockingReworkFinding);
+    if (resolutionsToApply.length > 0) {
+      // Snapshot the pre-resolution state of the findings we're about to
+      // change so a compensating rollback can restore them exactly (see
+      // revertAppliedReworkResolutions).
+      const resolvedFindingIdsForSnapshot = new Set(resolutionsToApply.map((r) => r.findingId));
+      appliedReworkSnapshot = getBlockingReworkFindingsForTask(
+        params.milestoneId,
+        params.sliceId,
+        params.taskId,
+      )
+        .filter((finding) => resolvedFindingIdsForSnapshot.has(finding.finding_id))
+        .map((finding) => ({
+          milestoneId: params.milestoneId,
+          sliceId: params.sliceId,
+          taskId: params.taskId,
+          findingId: finding.finding_id,
+          status: finding.status,
+          evidence: finding.evidence,
+          decisionRef: finding.decision_ref,
+        }));
+      applyReworkResolutions(resolutionsToApply);
+    }
+
     for (const evidence of (params.verificationEvidence ?? [])) {
       insertVerificationEvidence({
         taskId: params.taskId,
@@ -459,6 +591,7 @@ export async function handleCompleteTask(
       ensureWorkflowDbAtPath(rollbackDbPath);
       deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
       updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
+      revertAppliedReworkResolutions(appliedReworkSnapshot);
       invalidateStateCache();
       rollbackSucceeded = true;
     } catch (rollbackErr) {
@@ -559,6 +692,7 @@ export async function handleCompleteTask(
         try {
           deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
           updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+          revertAppliedReworkResolutions(appliedReworkSnapshot);
           invalidateStateCache();
           logWarning(
             "tool",
@@ -580,6 +714,7 @@ export async function handleCompleteTask(
       try {
         deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
         updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+        revertAppliedReworkResolutions(appliedReworkSnapshot);
         invalidateStateCache();
         logWarning(
           "tool",

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

@@ -5,7 +5,7 @@ import { getGateIdsForTurn } from "../gate-registry.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning, insertGateRow, setSliceSketchFlag } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.js";
-import { resolveTasksDir } from "../paths.js";
+import { resolveMilestonePath, resolveSlicePath } from "../paths.js";
 import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -255,21 +255,19 @@ export async function handlePlanTask(
   }
 
   try {
-    const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
-
-    // Flat-phase: tasks live as checkboxes in the slice plan's <tasks> block,
-    // not as standalone TID-PLAN.md files. Re-render the slice plan so the
-    // new/updated task appears in the plan file that gsd-core reads.
-    // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists).
+    const milestonePath = resolveMilestonePath(basePath, params.milestoneId);
+    const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+    const isLegacySliceLayout = Boolean(milestonePath && slicePath && slicePath !== milestonePath);
+    let renderedPath: string;
     let slicePlanSynced = false;
-    try {
-      const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-      if (!tDir) {
-        await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-        slicePlanSynced = true;
-      }
-    } catch (syncErr) {
-      logWarning("tool", `plan-task: slice-plan sync failed: ${(syncErr as Error).message}`);
+
+    if (isLegacySliceLayout) {
+      const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
+      renderedPath = renderResult.taskPlanPath;
+    } else {
+      const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+      renderedPath = renderResult.planPath;
+      slicePlanSynced = true;
     }
 
     if (slicePlanSynced) {
@@ -299,7 +297,7 @@ export async function handlePlanTask(
       milestoneId: params.milestoneId,
       sliceId: params.sliceId,
       taskId: params.taskId,
-      taskPlanPath: renderResult.taskPlanPath,
+      taskPlanPath: renderedPath,
     };
   } catch (err) {
     return { error: `render failed: ${(err as Error).message}` };

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -1,6 +1,6 @@
 import { existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { relSliceFile, resolveMilestoneFile, resolveMilestonePath, targetMilestoneFile } from "../paths.js";
+import { join, relative } from "node:path";
+import { gsdProjectionRoot, gsdRoot, resolveMilestoneFile, resolveMilestonePath, targetMilestoneFile } from "../paths.js";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
@@ -53,6 +53,14 @@ export interface ReassessRoadmapResult {
   roadmapPath: string;
 }
 
+function assessmentDbPathForRenderedFile(basePath: string, absPath: string): string {
+  const projectionRoot = gsdProjectionRoot(basePath);
+  const projectionRel = relative(projectionRoot, absPath);
+  const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+    ? projectionRoot
+    : gsdRoot(basePath);
+  return `.gsd/${relative(root, absPath).replace(/\\/g, "/")}`;
+}
 
 function validateParams(params: ReassessRoadmapParams): ReassessRoadmapParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
@@ -119,11 +127,6 @@ export async function handleReassessRoadmap(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
-  // ── Compute assessment artifact path ──────────────────────────────
-  // Assessment lives in the completed slice's directory.
-  // Use relSliceFile so the path is layout-aware (flat-phase or legacy).
-  const assessmentRelPath = relSliceFile(basePath, params.milestoneId, params.completedSliceId, "ASSESSMENT");
-
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).
@@ -207,16 +210,6 @@ export async function handleReassessRoadmap(
         }
       }
 
-      // Record assessment
-      insertAssessment({
-        path: assessmentRelPath,
-        milestoneId: params.milestoneId,
-        sliceId: params.completedSliceId,
-        status: params.verdict,
-        scope: "roadmap",
-        fullContent: params.assessment,
-      });
-
       // Apply slice modifications
       for (const mod of params.sliceChanges.modified) {
         updateSliceFields(params.milestoneId, mod.sliceId, {
@@ -282,6 +275,14 @@ export async function handleReassessRoadmap(
       assessment: params.assessment,
       completedSliceId: params.completedSliceId,
     });
+    insertAssessment({
+      path: assessmentDbPathForRenderedFile(basePath, assessmentResult.assessmentPath),
+      milestoneId: params.milestoneId,
+      sliceId: params.completedSliceId,
+      status: params.verdict,
+      scope: "roadmap",
+      fullContent: params.assessment,
+    });
 
     // ── Remove stale VALIDATION file from disk (#2957) ────────────
     const hasStructuralChanges =

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);
       }
     }

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

@@ -25,8 +25,16 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { writeReopenReason } from "../reopen-reason.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
+import { join } from "node:path";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveTasksDir,
+  resolveSlicePath,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenTaskParams {
   milestoneId: string;
@@ -113,13 +121,19 @@ export async function handleReopenTask(
   // summary cleanup into tasks/ (#1208).
   try {
     const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
-    if (slicePath) {
-      const isLegacySlice = basename(dirname(slicePath)) === "slices";
-      const summaryDir = isLegacySlice
-        ? (resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath)
-        : slicePath;
-      const summaryPath = join(summaryDir, `${params.taskId}-SUMMARY.md`);
-      if (existsSync(summaryPath)) unlinkSync(summaryPath);
+    const milestonePath = resolveMilestonePath(basePath, params.milestoneId);
+    if (milestonePath) {
+      const legacyBase = legacyMilestonesDir(basePath);
+      const isLegacy = milestonePath.startsWith(legacyBase + "/") || milestonePath.startsWith(legacyBase + "\\");
+      const summaryPaths = isLegacy
+        ? [join(resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath ?? join(milestonePath, "slices", params.sliceId, "tasks"), buildTaskFileName(params.taskId, "SUMMARY"))]
+        : [
+          join(milestonePath, buildFlatTaskFileName(params.sliceId, params.taskId, "SUMMARY")),
+          join(milestonePath, buildTaskFileName(params.taskId, "SUMMARY")),
+        ];
+      for (const summaryPath of summaryPaths) {
+        if (existsSync(summaryPath)) unlinkSync(summaryPath);
+      }
     }
   } catch (cleanupErr) {
     logWarning("tool", `reopen-task artifact cleanup warning: ${(cleanupErr as Error).message}`);