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

package/src/resources/extensions/gsd/tests/rework-brief.test.ts

@@ -0,0 +1,197 @@
+import { createTestContext } from './test-helpers.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  type ReworkBriefFindingInput,
+} from '../gsd-db.ts';
+import { handleReworkBriefSave } from '../tools/rework-brief.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-rework-brief-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanup(dbPath: string): void {
+  closeDatabase();
+  try {
+    const dir = path.dirname(dbPath);
+    for (const f of fs.readdirSync(dir)) fs.unlinkSync(path.join(dir, f));
+    fs.rmdirSync(dir);
+  } catch {
+    // best effort
+  }
+}
+
+function finding(overrides: Partial<ReworkBriefFindingInput> = {}): ReworkBriefFindingInput {
+  return {
+    findingId: 'F1',
+    severity: 'blocking',
+    description: 'Compile regression',
+    requiredFix: 'Fix compile error',
+    verificationCommands: ['pnpm run typecheck:extensions'],
+    ...overrides,
+  };
+}
+
+const baseParams = {
+  briefId: 'RB-001',
+  milestoneId: 'M001',
+  sliceId: 'S01',
+  taskId: 'T01',
+};
+
+function findingRow(): { status: string; evidence: string; decision_ref: string } | undefined {
+  return _getAdapter()!
+    .prepare("SELECT status, evidence, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'")
+    .get() as { status: string; evidence: string; decision_ref: string } | undefined;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: a blocking finding saved as non-pending must carry the same
+// justification a reworkResolution would, otherwise it bypasses the
+// gsd_task_complete blocking gate (which only sees `pending` rows).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: rejects blocking resolved finding without evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved' })],
+  });
+
+  assertTrue('error' in result, 'blocking resolved finding without evidence should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /evidence is required/i, 'error should mention the evidence requirement');
+  }
+  const rows = _getAdapter()!.prepare('SELECT COUNT(*) AS n FROM rework_brief_findings').get() as { n: number };
+  assertEq(rows.n, 0, 'no finding rows should be persisted when validation fails');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects blocking deferred-with-override without decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'deferred-with-override', evidence: 'Maintainer accepted temporary deferral.' })],
+  });
+
+  assertTrue('error' in result, 'deferred-with-override without decisionRef should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /decisionRef is required/i, 'error should mention the decisionRef requirement');
+  }
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects invalid finding status ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'bogus' as unknown as ReworkBriefFindingInput['status'] })],
+  });
+
+  assertTrue('error' in result, 'an unknown status value should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /status must be/i, 'error should name the allowed statuses');
+  }
+
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: legitimate saves still succeed.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: blocking finding defaults to pending ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding()],
+  });
+
+  assertTrue(!('error' in result), 'a blocking finding without a status should be accepted');
+  assertEq(findingRow()?.status, 'pending', 'finding without status should default to pending');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking resolved finding with evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved', evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.' })],
+  });
+
+  assertTrue(!('error' in result), 'a resolved blocking finding with evidence should be accepted');
+  assertEq(findingRow()?.status, 'resolved', 'finding should persist as resolved when evidence is supplied');
+  assertMatch(findingRow()?.evidence ?? '', /Fixed compile error/, 'resolution evidence should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking deferred-with-override with evidence and decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({
+      status: 'deferred-with-override',
+      evidence: 'Maintainer accepted temporary deferral.',
+      decisionRef: 'DEC-2026-07-07-rework-deferral',
+    })],
+  });
+
+  assertTrue(!('error' in result), 'a deferred-with-override finding with evidence and decisionRef should be accepted');
+  assertEq(findingRow()?.status, 'deferred-with-override', 'finding should persist the override status');
+  assertEq(findingRow()?.decision_ref, 'DEC-2026-07-07-rework-deferral', 'decision reference should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: advisory resolved finding does not require evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  // Advisory findings never gate gsd_task_complete, so pre-resolving one
+  // without evidence is harmless and stays permitted.
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ severity: 'advisory', status: 'resolved' })],
+  });
+
+  assertTrue(!('error' in result), 'an advisory resolved finding should be accepted without evidence');
+  assertEq(findingRow()?.status, 'resolved', 'advisory finding status should be preserved');
+
+  cleanup(dbPath);
+}
+
+report();

package/src/resources/extensions/gsd/tests/skip-slice-cascades-tasks.test.ts

@@ -25,6 +25,7 @@ import {
   updateTaskStatus,
 } from "../gsd-db.ts";
 import { handleSkipSlice } from "../tools/skip-slice.ts";
+import { skipSliceCascade } from "../db/writers/cascades.ts";
 
 describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
   let dir: string;
@@ -122,4 +123,24 @@ describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
     assert.match(result.error!, /not found/i);
     assert.equal(result.errorCode, "slice_not_found");
   });
+
+  test("skipSliceCascade rejects a slice in the legacy 'closed' status without nulling completed_at", () => {
+    const completedAt = "2026-01-01T00:00:00.000Z";
+    updateSliceStatus("M001", "S03", "closed", completedAt);
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.deepEqual(outcome, { ok: false, reason: "slice-already-complete" });
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "closed", "closed slice must not be downgraded to skipped");
+    assert.equal(slice?.completed_at, completedAt, "completed_at must be preserved");
+  });
+
+  test("skipSliceCascade still re-skips an already-skipped slice (ok, wasAlreadySkipped)", () => {
+    updateSliceStatus("M001", "S03", "skipped");
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.equal(outcome.ok, true);
+    if (outcome.ok) assert.equal(outcome.wasAlreadySkipped, true);
+  });
 });

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -107,11 +107,11 @@ test("ADR-017 (#5700): sketch-flag drift detected and repaired end-to-end", asyn
     sketchScope: "limited",
   });
 
-  // Simulate the post-crash scenario: PLAN.md exists on disk but the
-  // is_sketch flag is still 1.
+  // Simulate the post-crash scenario: a *real* PLAN.md (a decomposed task)
+  // exists on disk but the is_sketch flag is still 1.
   writeFileSync(
     join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md"),
-    "# S02 Plan\n",
+    makeStalePlanContent("S02", [{ id: "T01", title: "Build the feature", done: false }]),
   );
   assert.equal(getSlice("M001", "S02")?.is_sketch, 1, "pre: flagged as sketch");
 
@@ -131,6 +131,120 @@ test("ADR-017 (#5700): sketch-flag drift detected and repaired end-to-end", asyn
   }
 });
 
+test("#1287: stub/placeholder PLAN does NOT clear the sketch flag", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    id: "S02",
+    milestoneId: "M001",
+    title: "Feature",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "S02 demo.",
+    sequence: 1,
+    isSketch: true,
+    sketchScope: "limited",
+  });
+
+  const planPath = join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md");
+
+  // A bare stub PLAN (no decomposed tasks) must not clear the flag.
+  writeFileSync(planPath, "# S02 Plan\n");
+  clearRendererCaches();
+  let state = makeState({ activeMilestone: { id: "M001", title: "Test" } });
+  let result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => state,
+  });
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 1, "stub PLAN: flag stays set");
+  assert.equal(result.repaired.length, 0, "stub PLAN: no repair");
+
+  // A projection round-trip stub whose only task is a synthetic "Plan NN"
+  // placeholder (migrate/transformer.buildTaskTitle) must also not clear it.
+  writeFileSync(
+    planPath,
+    makeStalePlanContent("S02", [{ id: "T01", title: "Plan 01", done: false }]),
+  );
+  clearRendererCaches();
+  state = makeState({ activeMilestone: { id: "M001", title: "Test" } });
+  result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => state,
+  });
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 1, "placeholder task: flag stays set");
+  assert.equal(result.repaired.length, 0, "placeholder task: no repair");
+
+  // buildTaskTitle also emits `${phase} ${plan}` (e.g. "00 01") when the plan
+  // frontmatter carries phase/plan. This projected placeholder must not clear
+  // the flag either.
+  writeFileSync(
+    planPath,
+    makeStalePlanContent("S02", [{ id: "T01", title: "00 01", done: false }]),
+  );
+  clearRendererCaches();
+  state = makeState({ activeMilestone: { id: "M001", title: "Test" } });
+  result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => state,
+  });
+  assert.equal(result.ok, true);
+  assert.equal(
+    getSlice("M001", "S02")?.is_sketch,
+    1,
+    "phase/plan placeholder task: flag stays set",
+  );
+  assert.equal(result.repaired.length, 0, "phase/plan placeholder task: no repair");
+});
+
+test("#1288: real tasks shaped like `word + number` still clear the sketch flag", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    id: "S02",
+    milestoneId: "M001",
+    title: "Feature",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "S02 demo.",
+    sequence: 1,
+    isSketch: true,
+    sketchScope: "limited",
+  });
+
+  const planPath = join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md");
+
+  // `Step 1` / `RFC 1234` match the loose `word + number` shape but are genuine
+  // decomposed tasks. buildTaskTitle only emits `${phase} ${plan}` with a
+  // digit-led phase, so these must NOT be read as placeholders (#1288): a real
+  // plan-slice like this must still clear the stale is_sketch flag.
+  writeFileSync(
+    planPath,
+    makeStalePlanContent("S02", [
+      { id: "T01", title: "Step 1", done: false },
+      { id: "T02", title: "RFC 1234", done: false },
+    ]),
+  );
+  clearRendererCaches();
+  const state = makeState({ activeMilestone: { id: "M001", title: "Test" } });
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => state,
+  });
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "real task titles: flag cleared");
+  assert.equal(result.repaired.length, 1, "real task titles: repaired once");
+});
+
 test("ADR-017 (#5700): repair failure throws ReconciliationFailedError with shape", async () => {
   const seenDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
   const handler: DriftHandler = {
@@ -1032,7 +1146,7 @@ test("ADR-017 (#5703): live worker lock is not cleared", async (t) => {
 
 // ─── #5704: unregistered-milestone drift ────────────────────────────────────
 
-test("ADR-017 (#5704): unregistered-milestone drift fails closed without importing markdown", async (t) => {
+test("ADR-017 (#5704/#1281): unregistered-milestone drift pauses with a hint instead of hard-escalating", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-projmd-"));
   const milestoneDir = join(base, ".gsd", "phases", "42-test");
   mkdirSync(milestoneDir, { recursive: true });
@@ -1059,29 +1173,67 @@ test("ADR-017 (#5704): unregistered-milestone drift fails closed without importi
   // Pre-condition: filesystem has the milestone, DB does NOT.
   assert.equal(getMilestone("M042"), null, "pre: DB has no row for M042");
 
-  await assert.rejects(
-    reconcileBeforeDispatch(base, {
-      invalidateStateCache: () => {},
-      deriveState: async () => makeState(),
-    }),
-    (err: unknown) => {
-      assert.ok(err instanceof ReconciliationFailedError);
-      assert.match(String(err.message), /unregistered-milestone/);
-      assert.equal(err.failures[0]?.drift.kind, "unregistered-milestone");
-      assert.match(String(err.failures[0]?.cause), /M042/);
-      assert.match(String(err.failures[0]?.cause), /markdown projection/);
-      // Hint leads with targeted, non-destructive actions (rename/discard)...
-      assert.match(String(err.failures[0]?.cause), /Rename/);
-      assert.match(String(err.failures[0]?.cause), /Discard/);
-      // ...and reframes recover as a destructive last resort, not the fix (#826).
-      assert.match(String(err.failures[0]?.cause), /\/gsd recover/);
-      assert.match(String(err.failures[0]?.cause), /last resort/i);
-      return true;
-    },
-  );
+  // #1281: the handler exposes a `blocker`, so reconciliation returns a
+  // non-fatal pause-with-hint (ok:true + blocker) rather than throwing.
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+  assert.equal(result.ok, true);
+  const blocker = result.blockers.find((b) => /M042/.test(b));
+  assert.ok(blocker, "expected an M042 unregistered-milestone blocker");
+  assert.match(blocker!, /markdown projection/);
+  // Hint leads with targeted, non-destructive actions (rename/discard)...
+  assert.match(blocker!, /Rename/);
+  assert.match(blocker!, /Discard/);
+  // ...and reframes recover as a destructive last resort, not the fix (#826).
+  assert.match(blocker!, /\/gsd recover/);
+  assert.match(blocker!, /last resort/i);
+  // Runtime never imports markdown into the DB.
   assert.equal(getMilestone("M042"), null, "post: DB still has no row for M042");
 });
 
+test("#1281: descriptive flat-phase dir registered under a suffixed id → no false-positive drift", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-1281-suffix-"));
+  // Descriptive slug the flat-phase extractor cannot recover the suffix from →
+  // it derives the bare `M007`, which has no DB row.
+  const milestoneDir = join(base, ".gsd", "phases", "07-v40fmq-m007-v40fmq-navigation-footer-system");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M007-v40fmq-ROADMAP.md"),
+    [
+      "# M007: Navigation Footer System",
+      "",
+      "**Vision:** Verify no false-positive unregistered-milestone drift",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Foundation** `risk:medium` `depends:[]`",
+      "",
+    ].join("\n"),
+  );
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  // The milestone IS registered — under the unique_milestone_ids suffixed id.
+  insertMilestone({ id: "M007-v40fmq", title: "Navigation Footer System", status: "complete" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    result.blockers.some((b) => /unregistered/i.test(b) || /M007/.test(b)),
+    false,
+    "bare M007 derived from the slug must resolve to the registered M007-v40fmq row",
+  );
+});
+
 test("ADR-017 (#5704): registered milestone (DB row present) → no drift", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-projmd-clean-"));
   const milestoneDir = join(base, ".gsd", "phases", "01-test");
@@ -1977,7 +2129,7 @@ test("deriveState is pure: stale sketch healed only via reconcileBeforeDispatch"
   });
   writeFileSync(
     join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md"),
-    "# S02 Plan\n",
+    makeStalePlanContent("S02", [{ id: "T01", title: "Build the feature", done: false }]),
   );
 
   const { deriveState } = await import("../state.ts");

package/src/resources/extensions/gsd/tests/stop-notice.test.ts

@@ -14,6 +14,7 @@ import {
   isPauseNotice,
   isBlockedNoticeMessage,
   isManualResolutionNotice,
+  isInteractiveMenuUnavailableNotice,
   PAUSED_NOTICE_PREFIXES,
   TERMINAL_NOTICE_PREFIXES,
 } from "../stop-notice.js";
@@ -62,6 +63,22 @@ describe("emitter↔detector round-trip", () => {
     assert.ok(isBlockedNoticeMessage(message));
   });
 
+  test("un-showable menu notices classify as blocked (#1294)", () => {
+    // Emitted verbatim by notifyCommandMenuUnavailable (next-action-ui.ts / command-feedback.ts).
+    const menuUnavailable =
+      "gsd — m002: editorial hn menu could not be shown in this session.\nrun /gsd when ready.";
+    assert.ok(isInteractiveMenuUnavailableNotice(menuUnavailable));
+    assert.ok(isBlockedNoticeMessage(menuUnavailable));
+
+    // Emitted by notifyPickerCommandNeedsInteractiveMenu (command-feedback.ts).
+    const pickerGuidance = "/gsd did not start: milestone menu needs an interactive session";
+    assert.ok(isInteractiveMenuUnavailableNotice(pickerGuidance));
+    assert.ok(isBlockedNoticeMessage(pickerGuidance));
+
+    // Unrelated notices are not swept up.
+    assert.equal(isInteractiveMenuUnavailableNotice("auto-mode complete"), false);
+  });
+
   test("terminal prefixes cover the known stop vocabulary", () => {
     for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
       assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);

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

@@ -174,3 +174,22 @@ test('sync-lock: contended fresh lock fails fast without honoring long sync time
     cleanupDir(base);
   }
 });
+
+test('sync-lock: uncreatable lock path fails open instead of spinning forever', () => {
+  const base = tempDir();
+  try {
+    // `.gsd` is a dangling symlink to a missing target: the O_EXCL open lands
+    // on a missing parent and throws non-EEXIST on every attempt. Without the
+    // fail-open guard the retry loop spins forever, blocking the event loop.
+    fs.symlinkSync(path.join(base, 'missing-external-state'), path.join(base, '.gsd'), 'junction');
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 0, 'write-gate.lock');
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'uncreatable lock path must fail open, not acquire');
+    assert.ok(elapsedMs < 250, `must return promptly, not spin; elapsed=${elapsedMs.toFixed(1)}ms`);
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -43,6 +43,8 @@ import {
   insertMilestone,
   upsertMilestonePlanning,
   insertSlice,
+  insertTask,
+  saveReworkBrief,
 } from "../gsd-db.ts";
 
 // ─── Pure composer tests ──────────────────────────────────────────────────
@@ -518,6 +520,38 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
   assert.ok(!prompt.includes("Slice Context (from discussion)"));
 });
 
+
+test("execute-task prompt injects unresolved blocking rework findings", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  saveReworkBrief({
+    briefId: "RB-001",
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T01",
+    findings: [{
+      findingId: "F1",
+      severity: "blocking",
+      description: "Compile regression",
+      requiredFix: "Restore typecheck",
+      verificationCommands: ["pnpm run typecheck:extensions"],
+    }],
+  });
+
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "First", "T01", "Task", base);
+
+  assert.match(prompt, /Blocking Rework Findings \(non-optional\)/);
+  assert.match(prompt, /F1/);
+  assert.match(prompt, /Compile regression/);
+  assert.match(prompt, /pnpm run typecheck:extensions/);
+  assert.match(prompt, /reworkResolution/);
+});
+
 test("execute-task prompt omits on-demand slice research when the artifact is absent", async (t) => {
   const base = makeFixtureBase();
   t.after(() => cleanup(base));