@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

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/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

@@ -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")),
+      "stale metadata-only legacy milestones/ scaffold is not 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/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

@@ -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}` };