@opengsd/gsd-pi 1.8.0 → 1.8.1-dev.897b3c90

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -239,6 +239,98 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   assert.equal(isEmptyPlanV2GraphResult(compiled), true);
 });
 
+function seedMultiSliceRows(): void {
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  const slices: Array<[string, number, Array<[string, number]>]> = [
+    ["S01", 1, [["T01", 1], ["T02", 2]]],
+    ["S02", 2, [["T03", 1], ["T04", 2]]],
+  ];
+  for (const [sid, sseq, tasks] of slices) {
+    insertSlice({ id: sid, milestoneId: MILESTONE_ID, title: `Slice ${sid}`, status: "in_progress", sequence: sseq });
+    for (const [tid, tseq] of tasks) {
+      insertTask({
+        id: tid,
+        milestoneId: MILESTONE_ID,
+        sliceId: sid,
+        title: `Task ${tid}`,
+        status: "pending",
+        keyFiles: [`src/${tid}.ts`],
+        sequence: tseq,
+      });
+    }
+  }
+}
+
+test("plan-v2 batched compile preserves node ids, order, and count", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, true);
+
+  const graph = JSON.parse(readFileSync(compiled.graphPath ?? "", "utf-8")) as {
+    nodes: Array<{ id: string }>;
+  };
+  assert.deepEqual(
+    graph.nodes.map((n) => n.id),
+    [
+      "execute-task:M001:S01:T01",
+      "execute-task:M001:S01:T02",
+      "complete-slice:M001:S01",
+      "execute-task:M001:S02:T03",
+      "execute-task:M001:S02:T04",
+      "complete-slice:M001:S02",
+    ],
+  );
+});
+
+test("plan-v2 skips the disk write when the graph is unchanged", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(first.ok, true);
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+
+  // Backdate mtime so a rewrite is detectable even within the same millisecond.
+  utimesSync(graphPath, 1000, 1000);
+  const backdatedMtime = statSync(graphPath).mtimeMs;
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.equal(statSync(graphPath).mtimeMs, backdatedMtime, "identical state must not rewrite the graph");
+  assert.equal(readFileSync(graphPath, "utf-8"), before);
+});
+
+test("plan-v2 rewrites the graph when it changes", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+  utimesSync(graphPath, 1000, 1000);
+
+  insertTask({
+    id: "T05",
+    milestoneId: MILESTONE_ID,
+    sliceId: "S02",
+    title: "Added task",
+    status: "pending",
+    keyFiles: ["src/T05.ts"],
+    sequence: 3,
+  });
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.notEqual(statSync(graphPath).mtimeMs, 1000000, "changed graph must rewrite");
+  assert.notEqual(readFileSync(graphPath, "utf-8"), before);
+});
+
 test("plan-v2 allows empty graph for milestone terminal phases", () => {
   const basePath = createBasePath();
   writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");

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

@@ -94,6 +94,8 @@ test("complete-slice requires status, closeout, and execution handoff tools", ()
     "gsd_slice_complete",
     "gsd_task_reopen",
     "gsd_replan_slice",
+    "gsd_replan_task",
+    "gsd_rework_brief_save",
     "gsd_requirement_update",
     "gsd_summary_save",
   ];

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

@@ -0,0 +1,139 @@
+// GSD Extension - Auto-migration gate tests (plan 026).
+// Covers needsAutoMigration's trigger (empty milestones table + .gsd/milestones
+// present) and validateMigration's engine-vs-markdown count comparison.
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from '../gsd-db.ts';
+import { needsAutoMigration, validateMigration } from '../workflow-migration.ts';
+
+function makeProject(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-migration-gates-'));
+}
+
+function openProjectDb(base: string): string {
+  const gsdDir = join(base, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  const dbPath = join(gsdDir, 'gsd.db');
+  assert.ok(openDatabase(dbPath), 'openDatabase should succeed');
+  return dbPath;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeRoadmap(base: string, mId: string, sliceLines: string[]): void {
+  const mDir = join(base, '.gsd', 'milestones', mId);
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'ROADMAP.md'), [
+    `# ${mId}: Test`,
+    '',
+    '## Slices',
+    '',
+    ...sliceLines,
+    '',
+  ].join('\n'));
+}
+
+describe('needsAutoMigration', () => {
+  test('false for a fresh project with no legacy markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      assert.equal(needsAutoMigration(base), false, 'no .gsd/milestones dir → no migration');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('true when engine tables are empty and .gsd/milestones exists', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      assert.equal(needsAutoMigration(base), true, 'legacy markdown + empty engine → migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false once the milestones table has rows (migration already done)', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      insertMilestone({ id: 'M001', title: 'Migrated' });
+      assert.equal(needsAutoMigration(base), false, 'engine rows present → migration already done');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      closeDatabase();
+      assert.equal(needsAutoMigration(base), false, 'no DB → cannot migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe('validateMigration', () => {
+  test('reports no discrepancies when engine counts match markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', ['- [ ] **S01: Test Slice** `risk:low` `depends:[]`']);
+      insertMilestone({ id: 'M001', title: 'Test' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, [], 'matching engine/markdown counts → clean');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports discrepancies when engine counts diverge from markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', [
+        '- [ ] **S01: Test Slice** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second Slice** `risk:low` `depends:[]`',
+      ]);
+      // Engine has no rows at all → milestone and slice counts both diverge.
+      const result = validateMigration(base);
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Milestone count mismatch')),
+        `expected milestone mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Slice count mismatch')),
+        `expected slice mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports a validation failure when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      closeDatabase();
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, ['No database connection for validation']);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

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-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,6 +29,10 @@ 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";
@@ -185,6 +189,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 +339,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 +351,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 +394,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 +463,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 +576,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 +677,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 +699,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 =