@opengsd/gsd-pi 1.10.0 → 1.11.0

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -104,6 +104,30 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice re-dispatch preserves completed task checkboxes', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const first = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+
+    updateTaskStatus('M001', 'S02', 'T01', 'complete', '2026-07-11T00:00:00.000Z');
+
+    const second = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T01')?.done, true);
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T02')?.done, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice persists explicit slice/task target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -11,7 +11,7 @@
 import { describe, test, mock, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { tmpdir } from "node:os";
-import { mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
@@ -113,6 +113,15 @@ ${yamlLines.join("\n")}
   _clearGsdRootCache();
 }
 
+function useFlatPhaseLayout(): string {
+  rmSync(join(tempDir, ".gsd", "milestones"), { recursive: true, force: true });
+  const phaseDir = join(tempDir, ".gsd", "phases", "01-m001");
+  mkdirSync(phaseDir, { recursive: true });
+  invalidateAllCaches();
+  _clearGsdRootCache();
+  return phaseDir;
+}
+
 /**
  * Create a task in DB that will pass basic verification but allows us to test the flow.
  */
@@ -461,6 +470,34 @@ describe("Post-execution blocking failure retry bypass", () => {
     );
   });
 
+  test("flat-phase post-unit evidence writes slice-task VERIFY.json at phase level", async () => {
+    const phaseDir = useFlatPhaseLayout();
+    createPostExecFailureTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    const evidencePath = join(phaseDir, "S01-T01-VERIFY.json");
+    const legacyEvidencePath = join(phaseDir, "tasks", "T01-VERIFY.json");
+    assert.ok(existsSync(evidencePath), "flat-phase evidence should be written at phase level");
+    assert.equal(existsSync(legacyEvidencePath), false, "flat-phase evidence should not create legacy tasks/ path");
+
+    const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
+    assert.equal(evidence.passed, false);
+    assert.ok(Array.isArray(evidence.postExecutionChecks), "post-execution checks should be included in rewritten evidence");
+  });
+
   test("strict post-exec warning pause includes warning details", async () => {
     createPostExecWarningTask();
     writePreferences({

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -836,6 +836,31 @@ test("planning_subagents validation accepts configured read-only planning specia
   assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, ["scout", "security"]);
 });
 
+test("planning_subagents validation accepts custom agents registered as read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "my-custom-planner": { read_only_specialist: true },
+    },
+    planning_subagents: {
+      "plan-milestone": { allowed: ["planner", "my-custom-planner"] },
+      "plan-slice": { allowed: ["scout", "my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagent_registry?.["my-custom-planner"], {
+    read_only_specialist: true,
+  });
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "my-custom-planner",
+  ]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "my-custom-planner",
+  ]);
+});
+
 test("planning_subagents validation rejects unsupported units and unsafe agents", () => {
   const { preferences, errors } = validatePreferences({
     planning_subagents: {
@@ -849,6 +874,33 @@ test("planning_subagents validation rejects unsupported units and unsafe agents"
   assert.ok(errors.some(e => e.includes("\"worker\"") && e.includes("read-only planning specialist")));
 });
 
+test("planning_subagents validation explains how to register custom planning agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-slice": { allowed: ["my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("my-custom-planner") &&
+    e.includes("planning_subagent_registry.my-custom-planner.read_only_specialist: true")
+  ));
+});
+
+test("planning_subagent_registry validation requires explicit read_only_specialist true", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "write-capable-agent": { read_only_specialist: false },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagent_registry, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("planning_subagent_registry.write-capable-agent.read_only_specialist must be true")
+  ));
+});
+
 test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -874,9 +926,12 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
     [
       "---",
       "version: 1",
+      "planning_subagent_registry:",
+      "  global-custom-planner:",
+      "    read_only_specialist: true",
       "planning_subagents:",
       "  plan-slice:",
-      "    allowed: [scout, reviewer]",
+      "    allowed: [scout, reviewer, global-custom-planner]",
       "---",
       "",
     ].join("\n"),
@@ -887,11 +942,14 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
     [
       "---",
       "version: 1",
+      "planning_subagent_registry:",
+      "  project-custom-planner:",
+      "    read_only_specialist: true",
       "planning_subagents:",
       "  plan-slice:",
-      "    allowed: [security]",
+      "    allowed: [security, project-custom-planner]",
       "  plan-milestone:",
-      "    allowed: [planner]",
+      "    allowed: [planner, project-custom-planner]",
       "---",
       "",
     ].join("\n"),
@@ -899,12 +957,21 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
   );
 
   const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.deepEqual(loaded?.preferences.planning_subagent_registry, {
+    "global-custom-planner": { read_only_specialist: true },
+    "project-custom-planner": { read_only_specialist: true },
+  });
   assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-slice"]?.allowed, [
     "scout",
     "reviewer",
+    "global-custom-planner",
     "security",
+    "project-custom-planner",
+  ]);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "project-custom-planner",
   ]);
-  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, ["planner"]);
 });
 
 // ── Model config parsing ─────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -54,6 +54,9 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   },
   post_unit_hooks: [{ command: "npm test" }],
   pre_dispatch_hooks: [{ command: "npm run lint" }],
+  planning_subagent_registry: {
+    "custom-planner": { read_only_specialist: true },
+  },
   planning_subagents: {
     "plan-milestone": { allowed: ["scout", "planner"] },
     "plan-slice": { allowed: ["scout"] },

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -35,8 +35,8 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("gpt-5.5"), false);
   });
 
-  test("returns false for gpt-5.6 until service_tier payload support is verified", () => {
-    assert.equal(supportsServiceTier("gpt-5.6"), false);
+  test("returns false for gpt-5.6 variants until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.6-sol"), false);
   });
 
   test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts

@@ -51,6 +51,7 @@ const TYPED_DB_WRITER_FILES = new Set([
 ]);
 
 const SCHEMA_DB_WRITER_FILES = new Set([
+  "db-canonical-foundation-schema.ts",
   "db-memory-fts-schema.ts",
   "db-schema-metadata.ts",
   "db-verification-evidence-schema.ts",

package/src/resources/extensions/gsd/tests/thinking-level-resolution.test.ts

@@ -150,7 +150,7 @@ test("validation warns on an unknown phase key in the block", () => {
 
 test("validation warns on AND strips an illegal inline models thinking level", () => {
   const result = validatePreferences({
-    models: { planning: { model: "m", thinking: "max" } },
+    models: { planning: { model: "m", thinking: "ultra" } },
   } as never);
   assert.ok(result.warnings.some((w) => w.includes("models.planning.thinking") && w.includes("not a valid thinking level")));
   // The bad thinking field must be stripped so it can't reach the resolver,

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

@@ -99,6 +99,18 @@ test("verification-evidence: writeVerificationJSON creates directory if it doesn
   }
 });
 
+test("verification-evidence: writeVerificationJSON can write flat-phase slice-task filename", () => {
+  const tmp = makeTempDir("ve-flat-name");
+  try {
+    writeVerificationJSON(makeResult(), tmp, "T02", "M001/S03/T02", undefined, undefined, "S03");
+
+    assert.ok(existsSync(join(tmp, "S03-T02-VERIFY.json")), "flat-phase JSON file should exist");
+    assert.equal(existsSync(join(tmp, "T02-VERIFY.json")), false, "legacy JSON file should not be written");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 test("verification-evidence: writeVerificationJSON maps exitCode to verdict correctly", () => {
   const tmp = makeTempDir("ve-verdict");
   try {

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

@@ -0,0 +1,238 @@
+import assert from "node:assert/strict";
+import { spawnSync, type SpawnSyncReturns } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import test from "node:test";
+
+import type { CompleteSliceParams } from "../types.js";
+import {
+  closeDatabase,
+  getSlice,
+  getTask,
+  insertSlice,
+  insertTask,
+  updateTaskStatus,
+} from "../gsd-db.js";
+import { relSliceFile } from "../paths.js";
+import { handleCompleteSlice } from "../tools/complete-slice.js";
+import { createWorkflowAuthorityFixture } from "./workflow-authority-fixture.js";
+import {
+  createWorkflowFaultHarness,
+  type WorkflowFaultHarness,
+  type WorkflowFaultPoint,
+} from "./workflow-fault-harness.js";
+
+interface FaultScenario {
+  point: WorkflowFaultPoint;
+  committed: boolean;
+}
+
+interface AuthoritySnapshot {
+  pid: number;
+  taskStatus: string | null;
+  sliceStatus: string | null;
+  activeSlice: string | null;
+}
+
+const SCENARIOS: FaultScenario[] = [
+  { point: "before-transaction-commit", committed: false },
+  { point: "after-db-commit-before-render", committed: true },
+  { point: "during-projection-write", committed: true },
+  { point: "before-independent-reopen", committed: true },
+  { point: "after-independent-reopen", committed: true },
+];
+
+const COMPLETE_SLICE_PARAMS: CompleteSliceParams = {
+  milestoneId: "M001",
+  sliceId: "S02",
+  sliceTitle: "Ready dependent slice",
+  oneLiner: "Complete the dependent slice",
+  narrative: "The database records the completed slice before projections are refreshed.",
+  verification: "The focused authority matrix passed.",
+  uatContent: "## UAT Type\n\n- UAT mode: runtime-executable\n\n## Result\n\nPassed.",
+};
+
+function seedCompletionBoundary(): void {
+  updateTaskStatus("M001", "S02", "T01", "complete", "2026-07-11T00:00:00.000Z");
+  insertSlice({
+    id: "S03",
+    milestoneId: "M001",
+    title: "Blocked dependent slice",
+    status: "pending",
+    depends: ["S02"],
+    sequence: 3,
+  });
+  insertTask({
+    id: "T01",
+    milestoneId: "M001",
+    sliceId: "S03",
+    title: "Blocked task",
+    status: "pending",
+    sequence: 1,
+  });
+}
+
+function writeProjection(root: string, relativePath: string, content: string): void {
+  const path = join(root, ".gsd", relativePath);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+}
+
+function writeContradictoryProjection(root: string, committed: boolean): void {
+  const s02Checked = committed ? " " : "x";
+  const s03Checked = committed ? "x" : " ";
+  writeProjection(
+    root,
+    "milestones/M001/M001-ROADMAP.md",
+    [
+      "# M001: Contradictory projection",
+      "",
+      "## Slices",
+      "- [x] **S01: Completed prerequisite** `risk:low` `depends:[]`",
+      `- [${s02Checked}] **S02: Ready dependent slice** \`risk:medium\` \`depends:[S01]\``,
+      `- [${s03Checked}] **S03: Blocked dependent slice** \`risk:low\` \`depends:[S02]\``,
+    ].join("\n"),
+  );
+  writeProjection(
+    root,
+    "STATE.md",
+    [
+      "# GSD State",
+      "",
+      `**Active Slice:** ${committed ? "S02" : "S03"}`,
+      "**Phase:** executing",
+    ].join("\n"),
+  );
+}
+
+function armProductionFault(
+  point: WorkflowFaultPoint,
+  harness: WorkflowFaultHarness,
+  root: string,
+): void {
+  if (point === "before-transaction-commit") {
+    harness.armDatabaseAbort("status", "NEW.status = 'complete' AND OLD.status <> 'complete'");
+  } else if (point === "after-db-commit-before-render") {
+    harness.armDatabaseAbort("full_summary_md", "NEW.full_summary_md IS NOT OLD.full_summary_md");
+  } else if (point === "during-projection-write") {
+    const summaryPath = join(root, relSliceFile(root, "M001", "S02", "SUMMARY"));
+    harness.obstructProjection(summaryPath);
+  }
+}
+
+function runAuthorityProcess(
+  root: string,
+  dbPath: string,
+  faultPoint?: WorkflowFaultPoint,
+): SpawnSyncReturns<string> {
+  const resolver = join(process.cwd(), "src/resources/extensions/gsd/tests/resolve-ts.mjs");
+  const databaseModule = pathToFileURL(join(process.cwd(), "src/resources/extensions/gsd/gsd-db.ts")).href;
+  const stateModule = pathToFileURL(join(process.cwd(), "src/resources/extensions/gsd/state.ts")).href;
+  const faultHarnessModule = pathToFileURL(join(
+    process.cwd(),
+    "src/resources/extensions/gsd/tests/workflow-fault-harness.ts",
+  )).href;
+  const script = `
+    const [
+      { openDatabase, closeDatabase, getSlice, getTask },
+      { deriveStateFromDb },
+      { createWorkflowFaultHarness },
+    ] = await Promise.all([
+      import(${JSON.stringify(databaseModule)}),
+      import(${JSON.stringify(stateModule)}),
+      import(${JSON.stringify(faultHarnessModule)}),
+    ]);
+    const [root, dbPath, faultPoint] = process.argv.slice(-3);
+    if (!openDatabase(dbPath)) throw new Error("fresh process could not open workflow database");
+    if (faultPoint) {
+      process.stderr.write("DATABASE_OPENED_BEFORE_FAULT=" + process.pid + "\\n");
+      createWorkflowFaultHarness(faultPoint).hit(faultPoint, "fresh-process-reopen");
+    }
+    const state = await deriveStateFromDb(root);
+    const snapshot = {
+      pid: process.pid,
+      taskStatus: getTask("M001", "S02", "T01")?.status ?? null,
+      sliceStatus: getSlice("M001", "S02")?.status ?? null,
+      activeSlice: state.activeSlice?.id ?? null,
+    };
+    closeDatabase();
+    process.stdout.write("AUTHORITY_SNAPSHOT=" + JSON.stringify(snapshot) + "\\n");
+  `;
+  return spawnSync(
+    process.execPath,
+    [
+      "--import",
+      resolver,
+      "--experimental-strip-types",
+      "--input-type=module",
+      "--eval",
+      script,
+      root,
+      dbPath,
+      faultPoint ?? "",
+    ],
+    { cwd: process.cwd(), encoding: "utf8" },
+  );
+}
+
+function readAuthorityInFreshProcess(root: string, dbPath: string): AuthoritySnapshot {
+  const child = runAuthorityProcess(root, dbPath);
+
+  assert.equal(child.status, 0, child.stderr || child.stdout);
+  const line = child.stdout.split("\n").find((entry) => entry.startsWith("AUTHORITY_SNAPSHOT="));
+  assert.ok(line, `fresh process did not return an authority snapshot: ${child.stdout}`);
+  return JSON.parse(line.slice("AUTHORITY_SNAPSHOT=".length)) as AuthoritySnapshot;
+}
+
+for (const scenario of SCENARIOS) {
+  test(`database authority remains coherent at ${scenario.point}`, async (t) => {
+    const fixture = await createWorkflowAuthorityFixture();
+    t.after(() => fixture.cleanup());
+    seedCompletionBoundary();
+    const harness = createWorkflowFaultHarness(scenario.point);
+    armProductionFault(scenario.point, harness, fixture.root);
+
+    let completionError: unknown;
+    let completionStale = false;
+    try {
+      const result = await handleCompleteSlice(COMPLETE_SLICE_PARAMS, fixture.root);
+      assert.ok(!("error" in result), "production completion must reach its mutation boundary");
+      completionStale = result.stale === true;
+      harness.hit("before-independent-reopen", "complete-dependent-slice");
+    } catch (error) {
+      completionError = error;
+    }
+
+    if (scenario.point === "during-projection-write") {
+      assert.equal(completionStale, true, "the production renderer must surface a stale projection");
+    } else if (scenario.point === "after-independent-reopen") {
+      assert.equal(completionError, undefined, "completion must succeed before the reopen fault");
+      assert.equal(completionStale, false, "completion must not be stale before the reopen fault");
+    } else {
+      assert.match(String(completionError), new RegExp(scenario.point));
+    }
+
+    writeContradictoryProjection(fixture.root, scenario.committed);
+    closeDatabase();
+    if (scenario.point === "after-independent-reopen") {
+      const faultedChild = runAuthorityProcess(fixture.root, fixture.dbPath, scenario.point);
+      assert.notEqual(faultedChild.status, 0, "fresh process must fault after opening the database");
+      assert.match(faultedChild.stderr, /DATABASE_OPENED_BEFORE_FAULT=/);
+      assert.match(faultedChild.stderr, /after-independent-reopen/);
+    }
+    const snapshot = readAuthorityInFreshProcess(fixture.root, fixture.dbPath);
+    fixture.reopen();
+
+    const expectedStatus = scenario.committed ? "complete" : "pending";
+    const { pid, ...authority } = snapshot;
+    assert.notEqual(pid, process.pid, "authority must be verified by another process");
+    assert.deepEqual(authority, {
+      taskStatus: "complete",
+      sliceStatus: expectedStatus,
+      activeSlice: scenario.committed ? "S03" : "S02",
+    });
+    assert.equal(getTask("M001", "S02", "T01")?.status, "complete");
+    assert.equal(getSlice("M001", "S02")?.status, expectedStatus);
+  });
+}

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

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { queryDecisionsFromMemories, queryRequirements } from "../context-store.ts";
+import { deriveStateFromDb } from "../state.ts";
+import { createWorkflowAuthorityFixture } from "./workflow-authority-fixture.ts";
+
+test("workflow authority fixture seeds a reopenable DB-backed workflow", async (t) => {
+  const fixture = await createWorkflowAuthorityFixture();
+  t.after(() => fixture.cleanup());
+  fixture.reopen();
+
+  const state = await deriveStateFromDb(fixture.root);
+  const slices = getMilestoneSlices(fixture.ids.milestone);
+  const completedTasks = getSliceTasks(fixture.ids.milestone, fixture.ids.completedSlice);
+  const readyTasks = getSliceTasks(fixture.ids.milestone, fixture.ids.readySlice);
+  const requirements = queryRequirements({
+    milestoneId: fixture.ids.milestone,
+    sliceId: fixture.ids.readySlice,
+  });
+  const decisions = queryDecisionsFromMemories({ milestoneId: fixture.ids.milestone });
+
+  assert.equal(state.phase, "executing");
+  assert.equal(state.activeMilestone?.id, fixture.ids.milestone);
+  assert.equal(state.activeSlice?.id, fixture.ids.readySlice);
+  assert.equal(state.activeTask?.id, fixture.ids.readyTask);
+  assert.deepEqual(
+    slices.map((slice) => ({ id: slice.id, status: slice.status, depends: slice.depends })),
+    [
+      { id: fixture.ids.completedSlice, status: "complete", depends: [] },
+      { id: fixture.ids.readySlice, status: "pending", depends: [fixture.ids.completedSlice] },
+    ],
+  );
+  assert.deepEqual(
+    completedTasks.map((task) => ({ id: task.id, status: task.status })),
+    [{ id: fixture.ids.completedTask, status: "complete" }],
+  );
+  assert.deepEqual(
+    readyTasks.map((task) => ({ id: task.id, status: task.status })),
+    [{ id: fixture.ids.readyTask, status: "pending" }],
+  );
+  assert.ok(state.requirements);
+  assert.equal(state.requirements.active, 1);
+  assert.equal(state.requirements.total, 1);
+  assert.deepEqual(requirements.map((requirement) => requirement.id), [fixture.ids.requirement]);
+  assert.deepEqual(decisions.map((decision) => decision.id), [fixture.ids.decision]);
+});