@opengsd/gsd-pi 1.9.0-dev.e10b60d4 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/workflow-fault-harness.ts

@@ -0,0 +1,72 @@
+import { mkdirSync } from "node:fs";
+
+import { getDb } from "../gsd-db.js";
+
+export type WorkflowFaultPoint =
+  | "before-transaction-commit"
+  | "after-db-commit-before-render"
+  | "during-projection-write"
+  | "before-independent-reopen"
+  | "after-independent-reopen";
+
+export interface WorkflowFaultHarness {
+  hit(point: WorkflowFaultPoint, operation?: string): void;
+  count(point: WorkflowFaultPoint): number;
+  armDatabaseAbort(
+    column: "status" | "full_summary_md",
+    predicate:
+      | "NEW.status = 'complete' AND OLD.status <> 'complete'"
+      | "NEW.full_summary_md IS NOT OLD.full_summary_md",
+  ): void;
+  obstructProjection(path: string): void;
+}
+
+export class WorkflowFaultError extends Error {
+  readonly point: WorkflowFaultPoint;
+  readonly operation: string;
+  readonly hitCount: number;
+
+  constructor(point: WorkflowFaultPoint, operation: string, hitCount: number) {
+    super(`${operation} fault at ${point} (hit ${hitCount})`);
+    this.name = "WorkflowFaultError";
+    this.point = point;
+    this.operation = operation;
+    this.hitCount = hitCount;
+  }
+}
+
+export function createWorkflowFaultHarness(
+  armedPoint: WorkflowFaultPoint,
+): WorkflowFaultHarness {
+  const counts = new Map<WorkflowFaultPoint, number>();
+  let armed = true;
+
+  return {
+    hit(point, operation = "workflow-operation") {
+      const hitCount = (counts.get(point) ?? 0) + 1;
+      counts.set(point, hitCount);
+      if (armed && point === armedPoint) {
+        armed = false;
+        throw new WorkflowFaultError(point, operation, hitCount);
+      }
+    },
+    count(point) {
+      return counts.get(point) ?? 0;
+    },
+    armDatabaseAbort(column, predicate) {
+      const triggerName = `workflow_fault_${armedPoint.replaceAll("-", "_")}`;
+      const message = `complete-dependent-slice fault at ${armedPoint}`;
+      getDb().exec(`
+        CREATE TEMP TRIGGER ${triggerName}
+        BEFORE UPDATE OF ${column} ON slices
+        WHEN ${predicate}
+        BEGIN
+          SELECT RAISE(ABORT, '${message}');
+        END
+      `);
+    },
+    obstructProjection(path) {
+      mkdirSync(path, { recursive: true });
+    },
+  };
+}

package/src/resources/extensions/gsd/tests/worktree-state-projection.test.ts

@@ -117,8 +117,8 @@ test("projectRootToWorktree projects flat-phase discuss artifacts before dispatc
     new WorktreeStateProjection().projectRootToWorktree(scope);
 
     assert.ok(
-      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-META.json")),
-      "milestone metadata is projected into the worktree",
+      !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")),

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

@@ -7,12 +7,15 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, sep } from 'node:path';
 
 import { GSD_PHASE_SCOPE_DISPLAY_REASON, GSD_SECTION_CLOSE_GATE_DISPLAY_REASON } from '../auto-unit-tool-scope.ts';
 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 { clearGSDPreferencesCache, getProjectGSDPreferencesPath, loadEffectiveGSDPreferences } from '../preferences.ts';
 import { applyPlanningSubagentPreferences } from '../planning-subagent-policy.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
@@ -369,6 +372,43 @@ test('planning_subagents: widens plan-slice manifest allowlist without allowing
   assert.match(unsafe.reason!, /read-only specialists/);
 });
 
+test('planning_subagents: registered custom planning agents pass runtime read-only registry', (t) => {
+  const tempProject = mkdtempSync(join(tmpdir(), 'gsd-custom-planning-agent-'));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, '.gsd'), { recursive: true });
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      '---',
+      'version: 1',
+      'planning_subagent_registry:',
+      '  my-custom-planner:',
+      '    read_only_specialist: true',
+      'planning_subagents:',
+      '  plan-slice:',
+      '    allowed: [my-custom-planner]',
+      '---',
+      '',
+    ].join('\n'),
+    'utf-8',
+  );
+  clearGSDPreferencesCache();
+
+  const preferences = loadEffectiveGSDPreferences(tempProject)?.preferences;
+  const policy = applyPlanningSubagentPreferences('plan-slice', PLANNING_DISPATCH, preferences);
+  const custom = shouldBlockPlanningUnit('subagent', '', tempProject, 'plan-slice', policy, ['my-custom-planner']);
+  assert.strictEqual(custom.block, false, custom.reason);
+
+  const unregistered = shouldBlockPlanningUnit('subagent', '', tempProject, 'plan-slice', policy, ['other-planner']);
+  assert.strictEqual(unregistered.block, true);
+  assert.match(unregistered.reason!, /read-only specialists/);
+});
+
 // ─── planning mode: pass-through tools ────────────────────────────────────
 
 test('planning-unit: allows read tool', () => {

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -20,7 +20,7 @@ import {
 } from "../gsd-db.js";
 import type { GateEvaluationConfig, GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanFromDb } from "../markdown-renderer.js";
+import { renderPlanCheckboxes, renderPlanFromDb } from "../markdown-renderer.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -469,9 +469,13 @@ export async function handlePlanSlice(
     }
 
     const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+    const hasClosedTasks = sliceTasks.some((task) => isClosedStatus(task.status));
     const renderResult = sliceTasks.length === 0
       ? { planPath: "", taskPlanPaths: [] as string[] }
       : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+    if (sliceTasks.length > 0 && hasClosedTasks) {
+      await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
+    }
     if (sliceTasks.length > 0) {
       setSliceSketchFlag(params.milestoneId, params.sliceId, false);
     }

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

@@ -98,8 +98,9 @@ export interface EvidenceJSON {
 }
 
 /**
- * Write a T##-VERIFY.json artifact to the tasks directory.
+ * Write a T##-VERIFY.json artifact to the evidence directory.
  * Creates the directory with mkdirSync({ recursive: true }) if it doesn't exist.
+ * Flat-phase callers can pass sliceId to write S##-T##-VERIFY.json.
  *
  * stdout/stderr are excluded from the JSON — the full output lives in VerificationResult
  * in memory and is logged to stderr during the gate run.
@@ -111,6 +112,7 @@ export function writeVerificationJSON(
   unitId?: string,
   retryAttempt?: number,
   maxRetries?: number,
+  sliceId?: string,
 ): void {
   mkdirSync(tasksDir, { recursive: true });
 
@@ -150,7 +152,8 @@ export function writeVerificationJSON(
     }));
   }
 
-  const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+  const fileName = sliceId ? `${sliceId}-${taskId}-VERIFY.json` : `${taskId}-VERIFY.json`;
+  const filePath = join(tasksDir, fileName);
   writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
 

package/src/resources/extensions/gsd/worktree-state-projection.ts

@@ -32,7 +32,7 @@ import {
 import { join } from "node:path";
 
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import type { MilestoneScope } from "./workspace.js";
 import { logError, logWarning } from "./workflow-logger.js";
@@ -161,6 +161,7 @@ function syncOtherMilestoneArtifacts(
       // additive safeCopyRecursive; skip it here to avoid redundant work.
       if (milestoneEntry.name === currentMilestoneId) continue;
       const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+      if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir)) continue;
       const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
 
       // Additively project the entire milestone subtree (force:false), not just
@@ -271,36 +272,32 @@ export function _projectRootToWorktreeImpl(
   // Without this, worktree-local files (e.g. VALIDATION.md written
   // by validate-milestone) get clobbered by stale project root copies,
   // causing an infinite re-validation loop (#1886).
-  safeCopyRecursive(
-    join(prGsd, "milestones", milestoneId),
-    join(wtGsd, "milestones", milestoneId),
-    { force: false },
-  );
+  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
+  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+  if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
+    safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
+
+    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+    // The additive-only copy above preserves worktree-local files, but
+    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+    // syncs it to the project root, the worktree may retain a stale copy (e.g.
+    // verdict:fail while the project root has verdict:pass from a retry). On
+    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+    // run-uat indefinitely (stuck-loop ×9).
+    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+  }
 
-  // Additively project the full subtree of every OTHER milestone so
-  // worktree-bound units can read prior-milestone context artifacts and so
-  // completed milestones retain their per-slice/per-task SUMMARY.md and
-  // UAT.md on the worktree filesystem (otherwise the stale-render detector
-  // flags them as "complete in DB but missing on disk").
+  // Additively project the full subtree of every OTHER content-bearing legacy
+  // milestone so worktree-bound units can read prior-milestone context artifacts
+  // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
   syncOtherMilestoneArtifacts(
     join(prGsd, "milestones"),
     join(wtGsd, "milestones"),
     milestoneId,
   );
 
-  // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-  // The additive-only copy above preserves worktree-local files, but
-  // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-  // syncs it to the project root, the worktree may retain a stale copy (e.g.
-  // verdict:fail while the project root has verdict:pass from a retry). On
-  // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-  // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-  // run-uat indefinitely (stuck-loop ×9).
-  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
-  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-  forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-  forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
-
   // Forward-sync completed-units.json from project root to worktree.
   // Project root is authoritative for completion state after crash recovery;
   // without this, the worktree re-dispatches already-completed units (#1886).

package/src/resources/extensions/ollama/ollama-chat-provider.ts

@@ -207,7 +207,7 @@ export function streamOllamaChat(
  * - `"low" | "medium" | "high"` are passed through as strings; gpt-oss honors
  *   them as strength levels, other thinking models treat any present value
  *   as "thinking enabled".
- * - `"xhigh"` is collapsed to `"high"` (ollama caps strength at high).
+ * - `"xhigh"` and `"max"` are collapsed to `"high"` (ollama caps strength at high).
  */
 export function buildThinkParam(
 	model: Model<Api>,
@@ -217,7 +217,7 @@ export function buildThinkParam(
 	const level: ThinkingLevel | undefined = options?.reasoning;
 	if (level === undefined) return undefined;
 	if (level === "minimal") return false;
-	if (level === "xhigh") return "high";
+	if (level === "xhigh" || level === "max") return "high";
 	return level;
 }
 

package/src/resources/extensions/ollama/tests/ollama-chat-provider-think.test.ts

@@ -55,6 +55,10 @@ describe("buildThinkParam — ThinkingLevel mapping", () => {
 	it("collapses 'xhigh' to 'high' (ollama caps at high)", () => {
 		assert.equal(buildThinkParam(m, { reasoning: "xhigh" }), "high");
 	});
+
+	it("collapses 'max' to 'high' (ollama caps at high)", () => {
+		assert.equal(buildThinkParam(m, { reasoning: "max" }), "high");
+	});
 });
 
 describe("buildRequest — wire-level think field", () => {

package/src/resources/extensions/subagent/index.ts

@@ -735,7 +735,7 @@ async function runSingleAgentInCmuxSplit(
 	}
 }
 
-const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"] as const, {
+const ThinkingLevelSchema = StringEnum(["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const, {
 	description:
 		"Reasoning effort override for the subagent (forwarded as --thinking). " +
 		"Independent of model choice; unsupported levels are clamped to the model at dispatch.",