@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

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

@@ -268,7 +268,7 @@ test("#4934: every manifest declares a tools policy", () => {
 });
 
 test("#4934: tools.mode is one of the declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification"]);
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification", "workflow-only"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -327,23 +327,71 @@ test("#5453: complete-milestone uses all tools so bash verification is not plann
   }
 });
 
-test("#5731: validate-milestone and complete-slice use all tools so closeout verification is not planning-dispatch blocked", () => {
-  for (const unitType of ["validate-milestone", "complete-slice"] as const) {
-    const manifest = UNIT_MANIFESTS[unitType];
-    assert.strictEqual(manifest.tools.mode, "all");
-    const result = shouldBlockPlanningUnit(
-      "bash",
-      "go test -short -count=1 ./...",
-      process.cwd(),
-      unitType,
-      manifest.tools,
-    );
-    assert.strictEqual(
-      result.block,
-      false,
-      `${unitType} must allow verification bash commands: ${result.reason}`,
-    );
-  }
+test("#5731: complete-slice uses all tools so closeout verification is not planning-dispatch blocked", () => {
+  const manifest = UNIT_MANIFESTS["complete-slice"];
+  assert.strictEqual(manifest.tools.mode, "all");
+  const result = shouldBlockPlanningUnit(
+    "bash",
+    "go test -short -count=1 ./...",
+    process.cwd(),
+    "complete-slice",
+    manifest.tools,
+  );
+  assert.strictEqual(
+    result.block,
+    false,
+    `complete-slice must allow verification bash commands: ${result.reason}`,
+  );
+});
+
+test("#1157: validate-milestone uses workflow-only tools and blocks manual artifact writes", () => {
+  const manifest = UNIT_MANIFESTS["validate-milestone"];
+  assert.strictEqual(manifest.tools.mode, "workflow-only");
+  assert.deepEqual(resolveSubagentPermissionContract("validate-milestone"), {
+    allowed: true,
+    allowedSubagents: ["reviewer", "security", "tester"],
+    toolsMode: "workflow-only",
+  });
+
+  const validationWrite = shouldBlockPlanningUnit(
+    "write",
+    ".gsd/milestones/M001/M001-VALIDATION.md",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validationWrite.block, true);
+  assert.match(validationWrite.reason!, /workflow-only/);
+  assert.match(validationWrite.reason!, /direct artifact writes are disabled/);
+
+  const bash = shouldBlockPlanningUnit(
+    "bash",
+    "npm test",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(bash.block, true);
+  assert.match(bash.reason!, /bash is not permitted/);
+
+  const validateTool = shouldBlockPlanningUnit(
+    "gsd_validate_milestone",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validateTool.block, false);
+
+  const reviewer = shouldBlockPlanningUnit(
+    "subagent",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+    ["reviewer"],
+  );
+  assert.strictEqual(reviewer.block, false, reviewer.reason);
 });
 
 test("#5843: run-uat uses verification tools policy so build/test commands can run", () => {

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

@@ -6,7 +6,9 @@ import {
   formatExecuteTaskRecoveryStatus,
   inspectExecuteTaskDurability,
   isInFlightRuntimePhase,
+  readUnitHarnessAbort,
   readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
@@ -41,6 +43,34 @@ console.log("\n=== runtime record write/read/update ===");
   assert.deepStrictEqual(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
 }
 
+console.log("\n=== runtime harness abort preservation and explicit clear ===");
+{
+  const startedAt = 3000;
+  recordUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    kind: "tool-error",
+    reason: "Tool execution failed before the unit could complete its gate evaluation.",
+    toolName: "browser_click",
+  });
+
+  const preserved = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "wrapup-warning-sent",
+  });
+  assert.equal(preserved.harnessAbort?.kind, "tool-error", "ordinary same-run updates preserve harness abort");
+
+  const cleared = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "recovered",
+    harnessAbort: undefined,
+  });
+  assert.equal(cleared.harnessAbort, undefined, "explicit clear removes stale harness abort");
+  assert.equal(
+    readUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt),
+    null,
+    "cleared harness abort no longer blocks result saves",
+  );
+
+  clearUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3");
+}
+
 console.log("\n=== execute-task durability inspection ===");
 {
   let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -18,6 +18,7 @@ import { join } from "node:path";
 import { execSync } from "node:child_process";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 import { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
+import { _resetLogs, drainLogs } from "../workflow-logger.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -111,6 +112,43 @@ workspace:
   }
 });
 
+test("uok gitops turn action status-only reports dirty undeclared nested git repositories", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-nested-"));
+  try {
+    initRepo(root);
+    mkdirSync(join(root, "nested"), { recursive: true });
+    initRepo(join(root, "nested"));
+    writeFileSync(join(root, ".gitignore"), "nested/\n", "utf-8");
+    run("git add .gitignore", root);
+    run('git commit -m "chore: ignore nested repo"', root);
+
+    writeFileSync(join(root, "nested", "README.md"), "# Dirty nested\n", "utf-8");
+
+    _resetLogs();
+    const result = runTurnGitAction({
+      basePath: root,
+      action: "status-only",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+    const warnings = drainLogs();
+
+    assert.equal(result.status, "ok");
+    assert.equal(result.dirty, true);
+    assert.deepEqual(result.dirtyRepositories, {
+      project: false,
+      "nested (undeclared)": true,
+    });
+    assert.ok(
+      warnings.some((entry) => entry.message.includes("undeclared dirty nested git repo nested")),
+      "dirty undeclared nested repo should be logged as a warning",
+    );
+  } finally {
+    _resetLogs();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("uok gitops turn action snapshot writes snapshot refs", () => {
   const repo = makeRepo();
   try {
@@ -148,6 +186,58 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
   }
 });
 
+test("uok gitops turn action commit defaults to child repositories in parent mode", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-parent-commit-"));
+  try {
+    initRepo(root);
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    mkdirSync(join(root, "frontend"), { recursive: true });
+    mkdirSync(join(root, "backend"), { recursive: true });
+    initRepo(join(root, "frontend"));
+    initRepo(join(root, "backend"));
+    writeFileSync(join(root, ".gitignore"), "frontend/\nbackend/\n", "utf-8");
+    run("git add .gitignore", root);
+    run('git commit -m "chore: ignore nested repos"', root);
+    writeFileSync(join(root, ".gsd", "PREFERENCES.md"), `---
+version: 1
+workspace:
+  mode: parent
+  repositories:
+    frontend:
+      path: frontend
+    backend:
+      path: backend
+---
+`, "utf-8");
+    run("git add .gsd/PREFERENCES.md", root);
+    run('git commit -m "chore: configure parent workspace repos"', root);
+
+    const rootHeadBefore = run("git rev-parse HEAD", root);
+    writeFileSync(join(root, "frontend", "README.md"), "# frontend dirty\n", "utf-8");
+    writeFileSync(join(root, "backend", "README.md"), "# backend dirty\n", "utf-8");
+
+    const result = runTurnGitAction({
+      basePath: root,
+      action: "commit",
+      unitType: "execute-task",
+      unitId: "M001/S01/T-parent",
+    });
+
+    assert.equal(result.status, "ok");
+    assert.equal(result.commitMessages?.project, undefined);
+    assert.equal(typeof result.commitMessages?.frontend, "string");
+    assert.equal(typeof result.commitMessages?.backend, "string");
+    assert.equal(result.commitMessage, result.commitMessages?.frontend);
+    assert.equal(run("git rev-parse HEAD", root), rootHeadBefore);
+    assert.equal(run("git status --porcelain", join(root, "frontend")), "");
+    assert.equal(run("git status --porcelain", join(root, "backend")), "");
+    assert.ok(run("git log -1 --pretty=%B", join(root, "frontend")).includes("GSD-Unit: M001/S01/T-parent"));
+    assert.ok(run("git log -1 --pretty=%B", join(root, "backend")).includes("GSD-Unit: M001/S01/T-parent"));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("uok gitops turn action commit reuses the collected dirty status", () => {
   const repo = makeRepo();
   const wrapperDir = mkdtempSync(join(tmpdir(), "gsd-uok-git-wrapper-"));

package/src/resources/extensions/gsd/tests/validator-scope-parity.test.ts

@@ -23,7 +23,7 @@ import {
 
 function makeProjectDir(label = "gsd-vsp-"): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), label)));
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "phases", "01-m001"), { recursive: true });
   return dir;
 }
 
@@ -236,4 +236,56 @@ describe("validator-scope-parity: scope uses canonical projectRoot not worktree
       "verifyExpectedArtifactForScope should return false when artifact is absent",
     );
   });
+
+  test("verifyExpectedArtifactForScope rejects zero-slice scoped plan-milestone roadmaps", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    writeFileSync(scope.roadmapFile(), [
+      "# M001: Placeholder",
+      "",
+      "## Slices",
+      "",
+      "_TBD_",
+      "",
+    ].join("\n"));
+
+    const ready = verifyExpectedArtifactForScope(scope, "plan-milestone", "M001");
+    assert.equal(
+      ready,
+      false,
+      "scoped plan-milestone verification must parse roadmap content, not only check existence",
+    );
+  });
+
+  test("verifyExpectedArtifactForScope verifies the scoped plan-milestone roadmap path", () => {
+    const ws = createWorkspace(base);
+    const realScope = scopeMilestone(ws, "M001");
+    const scopedRoadmap = join(base, "scoped-M001-ROADMAP.md");
+    const scope = {
+      ...realScope,
+      roadmapFile: () => scopedRoadmap,
+    };
+
+    writeFileSync(scopedRoadmap, [
+      "# M001: Scoped roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    assert.equal(
+      resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001"),
+      scopedRoadmap,
+      "scoped plan-milestone artifact path must come from scope.roadmapFile()",
+    );
+    assert.equal(
+      verifyExpectedArtifactForScope(scope, "plan-milestone", "M001"),
+      true,
+      "scoped plan-milestone verification must read the roadmap from scope.roadmapFile()",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -11,6 +11,8 @@ import {
   verificationRetryKey,
   VERIFICATION_RETRY_MAX_DELAY_MS,
 } from "../auto/verification-retry-policy.ts";
+import { formatFailureContext, formatFailureSignature } from "../verification-gate.ts";
+import type { VerificationResult } from "../types.ts";
 
 test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
@@ -31,9 +33,22 @@ test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   });
 });
 
-test("decideVerificationRetry pauses on duplicate failure context", () => {
+test("decideVerificationRetry pauses on repeated failure context across attempts", () => {
   const failureContext = "lint failed\n";
-  const failureHash = hashVerificationFailureContext(failureContext);
+  const firstDecision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 1,
+    },
+    previousFailureHash: undefined,
+    random: () => 0.5,
+  });
+
+  assert.equal(firstDecision.action, "delay");
+  assert.equal(firstDecision.failureHash, hashVerificationFailureContext(failureContext));
+
   const decision = decideVerificationRetry({
     unitType: "execute-task",
     retryInfo: {
@@ -41,7 +56,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
       failureContext,
       attempt: 2,
     },
-    previousFailureHash: failureHash,
+    previousFailureHash: firstDecision.failureHash,
     random: () => 0.5,
   });
 
@@ -49,7 +64,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
     action: "pause",
     reason: "duplicate-failure-context",
     key: verificationRetryKey("execute-task", "M001/S01/T01"),
-    failureHash,
+    failureHash: firstDecision.failureHash,
   });
 });
 
@@ -71,6 +86,56 @@ test("decideVerificationRetry delays changed failure context", () => {
   assert.equal(decision.baseDelayMs, 4_000);
 });
 
+test("decideVerificationRetry pauses duplicate host-check failures with volatile stderr", () => {
+  const makeResult = (stderr: string): VerificationResult => ({
+    passed: false,
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+    checks: [
+      {
+        command: "npm test",
+        exitCode: 1,
+        stdout: "",
+        stderr,
+        durationMs: 100,
+      },
+    ],
+  });
+  const first = makeResult("failed after 120ms in /tmp/gsd-a worker pid 101");
+  const second = makeResult("failed after 133ms in /tmp/gsd-b worker pid 202");
+  const firstContext = formatFailureContext(first);
+  const secondContext = formatFailureContext(second);
+
+  assert.notEqual(
+    hashVerificationFailureContext(firstContext),
+    hashVerificationFailureContext(secondContext),
+  );
+
+  const signature = formatFailureSignature(first);
+  assert.equal(signature, "npm test#1");
+  assert.equal(formatFailureSignature(second), signature);
+
+  const failureHash = hashVerificationFailureContext(signature);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: secondContext,
+      signature: formatFailureSignature(second),
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
 test("decideVerificationRetry pauses when retry context is missing", () => {
   assert.deepEqual(
     decideVerificationRetry({

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

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import {
   writeManifest,
+  flushManifest,
   readManifest,
   snapshotState,
   bootstrapFromManifest,
@@ -42,6 +43,11 @@ function cleanupDir(dirPath: string): void {
   try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
 }
 
+async function writeManifestAndFlush(base: string): Promise<void> {
+  writeManifest(base);
+  await flushManifest(base);
+}
+
 function insertMemoryBackedDecision(id: string): void {
   const now = '2026-01-01T00:00:00.000Z';
   insertMemoryRow({
@@ -83,12 +89,14 @@ test('workflow-manifest: readManifest returns null when file does not exist', ()
 
 // ─── writeManifest + readManifest round-trip ─────────────────────────────
 
-test('workflow-manifest: writeManifest creates state-manifest.json with version 1', () => {
+test('workflow-manifest: writeManifest creates state-manifest.json with version 1 after flush', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     writeManifest(base);
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.equal(fs.existsSync(manifestPath), false, 'writeManifest should not synchronously write state-manifest.json');
+    await flushManifest(base);
     assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist');
     const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     assert.strictEqual(raw.version, 1);
@@ -98,11 +106,11 @@ test('workflow-manifest: writeManifest creates state-manifest.json with version
   }
 });
 
-test('workflow-manifest: readManifest parses manifest written by writeManifest', () => {
+test('workflow-manifest: readManifest parses manifest written by writeManifest', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     const manifest = readManifest(base);
     assert.ok(manifest !== null);
     assert.strictEqual(manifest!.version, 1);
@@ -124,6 +132,25 @@ test('workflow-manifest: readManifest parses manifest written by writeManifest',
   }
 });
 
+test('workflow-manifest: flushManifest writes the latest queued payload', async () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'First Milestone' });
+    writeManifest(base);
+    insertMilestone({ id: 'M002', title: 'Latest Milestone' });
+    writeManifest(base);
+
+    await flushManifest(base);
+
+    const manifest = readManifest(base);
+    assert.ok(manifest?.milestones.some((m) => m.id === 'M002'), 'latest queued write should be durable');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
 // ─── snapshotState: captures DB rows ─────────────────────────────────────
 
 test('workflow-manifest: snapshotState includes inserted milestone', () => {
@@ -181,7 +208,7 @@ test('workflow-manifest: snapshotState captures memory-backed decisions', () =>
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', () => {
+test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -256,7 +283,7 @@ test('workflow-manifest: bootstrapFromManifest restores extended correctness row
       createdAt: '2026-06-05T00:00:00.000Z',
     });
 
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -306,7 +333,7 @@ test('workflow-manifest: bootstrapFromManifest returns false when no manifest fi
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', () => {
+test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -326,7 +353,7 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
       status: 'complete',
       planning: { fullPlanMd: '# Full Task Plan\n\nKeep this body.', targetRepositories: ['project'] },
     });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     // Open a fresh DB and bootstrap from manifest
@@ -356,14 +383,14 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves target_repositories', () => {
+test('workflow-manifest: bootstrapFromManifest preserves target_repositories', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Restored Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['frontend'] } });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['backend'] } });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -380,14 +407,68 @@ test('workflow-manifest: bootstrapFromManifest preserves target_repositories', (
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', () => {
+test('workflow-manifest: bootstrapFromManifest does not truncate projections when artifact content is empty', async () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'Projection Milestone' });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-PLAN.md',
+      artifact_type: 'PLAN',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Plan',
+    });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-VALIDATION.md',
+      artifact_type: 'VALIDATION',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Validation',
+    });
+    await writeManifestAndFlush(base);
+
+    const planPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-PLAN.md');
+    const validationPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    fs.mkdirSync(path.dirname(planPath), { recursive: true });
+    fs.writeFileSync(planPath, '# Existing Plan\n\nKeep this.');
+    fs.writeFileSync(validationPath, '# Existing Validation\n\nKeep this.');
+
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
+    const artifacts = manifest['artifacts'] as Array<Record<string, unknown>>;
+    const emptyArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-PLAN.md');
+    const absentArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-VALIDATION.md');
+    assert.ok(emptyArtifact !== undefined);
+    assert.ok(absentArtifact !== undefined);
+    emptyArtifact['full_content'] = '';
+    delete absentArtifact['full_content'];
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    closeDatabase();
+
+    const newDbPath = path.join(base, 'new.db');
+    openDatabase(newDbPath);
+    const restored = bootstrapFromManifest(base);
+    assert.strictEqual(restored, true);
+
+    assert.strictEqual(fs.readFileSync(planPath, 'utf-8'), '# Existing Plan\n\nKeep this.');
+    assert.strictEqual(fs.readFileSync(validationPath, 'utf-8'), '# Existing Validation\n\nKeep this.');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Old Manifest Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Old Manifest Slice' });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Old Manifest Task' });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
 
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
     const oldManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
@@ -450,12 +531,12 @@ test('workflow-manifest: bootstrapFromManifest preserves optional rows from old
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D901');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -472,12 +553,12 @@ test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions'
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D902');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');

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

@@ -29,6 +29,7 @@ test("preflight uses inline workflow MCP config when no project config is persis
         `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
         'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
         'server.tool("gsd_plan_slice", "Plan slice", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+        'server.tool("gsd_plan_task", "Plan task", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
         'server.tool("gsd_reassess_roadmap", "Reassess roadmap", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
         'await server.connect(new StdioServerTransport());',
       ].join("\n"),