gsd-pi 3.0.0-dev.2e8b124f7 → 3.0.0-dev.6c9a50fd0

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

@@ -10,6 +10,7 @@ import {
   closeDatabase,
   _getAdapter,
   insertGateRow,
+  insertAssessment,
   upsertRequirement,
   getAllMilestones,
 } from "../gsd-db.ts";
@@ -26,6 +27,7 @@ import {
   executeTaskComplete,
   executeMilestoneStatus,
   executeSliceComplete,
+  executeSliceReopen,
   executeValidateMilestone,
 } from "../tools/workflow-tool-executors.ts";
 
@@ -146,6 +148,117 @@ test("executeTaskComplete coerces string verificationEvidence entries", async ()
   }
 });
 
+test("executeSliceComplete preserves omitted optional requirement arrays", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, () => executePlanMilestone({
+      milestoneId: "M001",
+      title: "Requirement preservation",
+      vision: "Ensure omitted arrays are not coerced to empties.",
+      slices: [
+        {
+          sliceId: "S01",
+          title: "Slice",
+          risk: "medium",
+          depends: [],
+          demo: "demo",
+          goal: "goal",
+          successCriteria: "done",
+          proofLevel: "integration",
+          integrationClosure: "closed",
+          observabilityImpact: "covered",
+        },
+      ],
+    }, base));
+    await inProjectDir(base, () => executePlanSlice({
+      milestoneId: "M001",
+      sliceId: "S01",
+      goal: "goal",
+      tasks: [
+        {
+          taskId: "T01",
+          title: "Task",
+          description: "desc",
+          estimate: "5m",
+          files: ["src/a.ts"],
+          verify: "node --test",
+          inputs: ["in"],
+          expectedOutput: ["out"],
+        },
+      ],
+    }, base));
+    await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "done",
+      narrative: "done",
+      verification: "ok",
+    }, base));
+
+    const result = await inProjectDir(base, () => executeSliceComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      sliceTitle: "Slice",
+      oneLiner: "done",
+      narrative: "done",
+      verification: "ok",
+      uatContent: "ok",
+      requirementsAdvanced: [{ id: "R010", how: "advanced" }],
+      requirementsValidated: [{ id: "R010", proof: "validated" }],
+    }, base));
+
+    assert.equal(result.details.operation, "complete_slice");
+    const summaryPath = String(result.details.summaryPath);
+    const summary = readFileSync(summaryPath, "utf-8");
+    assert.match(summary, /R010 — advanced/);
+    assert.match(summary, /R010 — validated/);
+
+    const reopenResult = await inProjectDir(base, () => executeSliceReopen({
+      milestoneId: "M001",
+      sliceId: "S01",
+      reason: "validate idempotent overwrite behavior",
+    }, base));
+    assert.equal(reopenResult.details.operation, "reopen_slice");
+    await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "done (updated)",
+      narrative: "done (updated)",
+      verification: "ok",
+    }, base));
+
+    const recallResult = await inProjectDir(base, () => executeSliceComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      sliceTitle: "Slice",
+      oneLiner: "done (updated)",
+      narrative: "done (updated)",
+      verification: "ok",
+      uatContent: "ok",
+    }, base));
+
+    assert.equal(recallResult.details.operation, "complete_slice");
+    const recallSummaryPath = String(recallResult.details.summaryPath);
+    const recallSummary = readFileSync(recallSummaryPath, "utf-8");
+    assert.match(
+      recallSummary,
+      /R010 — advanced/,
+      "requirementsAdvanced should be preserved from first call",
+    );
+    assert.match(
+      recallSummary,
+      /R010 — validated/,
+      "requirementsValidated should be preserved from first call",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeMilestoneStatus returns milestone metadata and slice counts", async () => {
   const base = makeTmpBase();
   try {
@@ -371,6 +484,13 @@ test("executeCompleteMilestone sanitizes raw params and writes milestone summary
     db!.prepare(
       "INSERT OR REPLACE INTO tasks (milestone_id, slice_id, id, title, status) VALUES (?, ?, ?, ?, ?)",
     ).run("M003", "S03", "T03", "Task T03", "complete");
+    insertAssessment({
+      path: join(".gsd", "milestones", "M003", "M003-VALIDATION.md"),
+      milestoneId: "M003",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nValidated.",
+    });
 
     const rawParams = {
       milestoneId: "M003",

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

@@ -129,6 +129,50 @@ describe("Worktree Safety module", () => {
     assert.equal(result.details?.expectedRoot, unitRoot);
   });
 
+  test("accepts project root for source-writing Unit when isolation mode is none", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: projectRoot, branch: "main" }],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot: projectRoot,
+      milestoneId: "M001",
+      isolationMode: "none",
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.kind, "safe");
+  });
+
+  test("rejects non-project root for source-writing Unit when isolation mode is none", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "main" }],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      isolationMode: "none",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "invalid-root");
+    assert.equal(result.details?.expectedRoot, projectRoot);
+    assert.equal(result.details?.unitRoot, unitRoot);
+  });
+
   test("rejects a standalone repository masquerading as a worktree", () => {
     unlinkSync(join(unitRoot, ".git"));
     mkdirSync(join(unitRoot, ".git"), { recursive: true });

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -15,6 +15,7 @@ import {
   getMilestone,
   getMilestoneSlices,
   getSliceTasks,
+  getLatestAssessmentByScope,
   updateMilestoneStatus,
 } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
@@ -156,6 +157,15 @@ export async function handleCompleteMilestone(
       return;
     }
 
+    // Defense-in-depth: only a passing milestone validation permits closeout.
+    const validation = getLatestAssessmentByScope(params.milestoneId, "milestone-validation");
+    if (validation?.status !== "pass") {
+      guardError =
+        `Refusing to complete ${params.milestoneId}: latest milestone-validation verdict is ` +
+        `"${validation?.status ?? "absent"}". Only verdict=pass permits closeout.`;
+      return;
+    }
+
     // Verify all slices are complete
     const slices = getMilestoneSlices(params.milestoneId);
     if (slices.length === 0) {

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

@@ -232,6 +232,34 @@ ${params.uatContent}
 `;
 }
 
+function parseRequirementSection(
+  summaryMd: string,
+  heading: "Requirements Advanced" | "Requirements Validated" | "Requirements Invalidated or Re-scoped",
+  field: "how" | "proof" | "what",
+): Array<{ id: string; how?: string; proof?: string; what?: string }> {
+  const headingLine = `## ${heading}\n\n`;
+  const start = summaryMd.indexOf(headingLine);
+  if (start === -1) return [];
+  const contentStart = start + headingLine.length;
+  const nextHeading = summaryMd.indexOf("\n\n## ", contentStart);
+  const content = nextHeading === -1
+    ? summaryMd.slice(contentStart)
+    : summaryMd.slice(contentStart, nextHeading);
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("- "))
+    .map((line) => line.slice(2).trim())
+    .map((line) => {
+      const pair = line.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
+      const id = pair ? pair[1].trim() : line.trim();
+      const detail = pair ? pair[2].trim() : "";
+      if (!id || !detail) return null;
+      return { id, [field]: detail };
+    })
+    .filter((entry): entry is { id: string; how?: string; proof?: string; what?: string } => entry !== null);
+}
+
 /**
  * Handle the complete_slice operation end-to-end.
  *
@@ -277,6 +305,7 @@ export async function handleCompleteSlice(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let existingSummaryMd = "";
 
   transaction(() => {
     // State machine preconditions (inside txn for atomicity).
@@ -289,6 +318,7 @@ export async function handleCompleteSlice(
     }
 
     const slice = getSlice(params.milestoneId, params.sliceId);
+    existingSummaryMd = slice?.full_summary_md?.trim() ?? "";
     if (slice && isClosedStatus(slice.status)) {
       if (isStaleWrite("complete-slice")) {
         guardError = "__stale_duplicate__";
@@ -347,8 +377,27 @@ export async function handleCompleteSlice(
     return { error: guardError };
   }
 
+  const effectiveParams: CompleteSliceParams = { ...params };
+  if (existingSummaryMd) {
+    // Keep these heading names in lock-step with renderSliceSummaryMarkdown's
+    // section titles so omitted CompleteSliceParams requirement fields can be
+    // backfilled from previously rendered summary markdown.
+    if (effectiveParams.requirementsAdvanced === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Advanced", "how");
+      if (parsed.length > 0) effectiveParams.requirementsAdvanced = parsed as Array<{ id: string; how: string }>;
+    }
+    if (effectiveParams.requirementsValidated === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Validated", "proof");
+      if (parsed.length > 0) effectiveParams.requirementsValidated = parsed as Array<{ id: string; proof: string }>;
+    }
+    if (effectiveParams.requirementsInvalidated === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Invalidated or Re-scoped", "what");
+      if (parsed.length > 0) effectiveParams.requirementsInvalidated = parsed as Array<{ id: string; what: string }>;
+    }
+  }
+
   // Render summary markdown
-  const summaryMd = renderSliceSummaryMarkdown(params);
+  const summaryMd = renderSliceSummaryMarkdown(effectiveParams);
 
   // Resolve and write summary to disk
   let summaryPath: string;
@@ -363,7 +412,7 @@ export async function handleCompleteSlice(
     summaryPath = join(manualSliceDir, `${params.sliceId}-SUMMARY.md`);
   }
 
-  const uatMd = renderUatMarkdown(params);
+  const uatMd = renderUatMarkdown(effectiveParams);
   const uatPath = summaryPath.replace(/-SUMMARY\.md$/, "-UAT.md");
   setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
   let projectionStale = false;

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -523,39 +523,53 @@ export async function executeSliceComplete(
       const m = s.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
       return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
     };
-    const wrapArray = (v: unknown): unknown[] =>
-      v == null ? [] : Array.isArray(v) ? v : [v];
-
-    const coerced = { ...params } as CompleteSliceParams & Record<string, unknown>;
-    coerced.provides = wrapArray(params.provides) as string[];
-    coerced.keyFiles = wrapArray(params.keyFiles) as string[];
-    coerced.keyDecisions = wrapArray(params.keyDecisions) as string[];
-    coerced.patternsEstablished = wrapArray(params.patternsEstablished) as string[];
-    coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces) as string[];
-    coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced) as string[];
-    coerced.drillDownPaths = wrapArray(params.drillDownPaths) as string[];
-    coerced.affects = wrapArray(params.affects) as string[];
-    coerced.filesModified = wrapArray(params.filesModified).map((f) => {
+    const wrapOptionalArray = (v: unknown): unknown[] | undefined =>
+      v == null ? undefined : Array.isArray(v) ? v : [v];
+    const coerced = Object.fromEntries(
+      Object.entries(params).filter(([, value]) => value !== undefined && value !== null),
+    ) as CompleteSliceParams & Record<string, unknown>;
+    const provides = wrapOptionalArray(params.provides);
+    if (provides !== undefined) coerced.provides = provides as string[];
+    const keyFiles = wrapOptionalArray(params.keyFiles);
+    if (keyFiles !== undefined) coerced.keyFiles = keyFiles as string[];
+    const keyDecisions = wrapOptionalArray(params.keyDecisions);
+    if (keyDecisions !== undefined) coerced.keyDecisions = keyDecisions as string[];
+    const patternsEstablished = wrapOptionalArray(params.patternsEstablished);
+    if (patternsEstablished !== undefined) coerced.patternsEstablished = patternsEstablished as string[];
+    const observabilitySurfaces = wrapOptionalArray(params.observabilitySurfaces);
+    if (observabilitySurfaces !== undefined) coerced.observabilitySurfaces = observabilitySurfaces as string[];
+    const requirementsSurfaced = wrapOptionalArray(params.requirementsSurfaced);
+    if (requirementsSurfaced !== undefined) coerced.requirementsSurfaced = requirementsSurfaced as string[];
+    const drillDownPaths = wrapOptionalArray(params.drillDownPaths);
+    if (drillDownPaths !== undefined) coerced.drillDownPaths = drillDownPaths as string[];
+    const affects = wrapOptionalArray(params.affects);
+    if (affects !== undefined) coerced.affects = affects as string[];
+    const filesModified = wrapOptionalArray(params.filesModified);
+    if (filesModified !== undefined) coerced.filesModified = filesModified.map((f) => {
       if (typeof f !== "string") return f;
       const [path, description] = splitPair(f);
       return { path, description };
     }) as Array<{ path: string; description: string }>;
-    coerced.requires = wrapArray(params.requires).map((r) => {
+    const requires = wrapOptionalArray(params.requires);
+    if (requires !== undefined) coerced.requires = requires.map((r) => {
       if (typeof r !== "string") return r;
       const [slice, provides] = splitPair(r);
       return { slice, provides };
     }) as Array<{ slice: string; provides: string }>;
-    coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
+    const requirementsAdvanced = wrapOptionalArray(params.requirementsAdvanced);
+    if (requirementsAdvanced !== undefined) coerced.requirementsAdvanced = requirementsAdvanced.map((r) => {
       if (typeof r !== "string") return r;
       const [id, how] = splitPair(r);
       return { id, how };
     }) as Array<{ id: string; how: string }>;
-    coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
+    const requirementsValidated = wrapOptionalArray(params.requirementsValidated);
+    if (requirementsValidated !== undefined) coerced.requirementsValidated = requirementsValidated.map((r) => {
       if (typeof r !== "string") return r;
       const [id, proof] = splitPair(r);
       return { id, proof };
     }) as Array<{ id: string; proof: string }>;
-    coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
+    const requirementsInvalidated = wrapOptionalArray(params.requirementsInvalidated);
+    if (requirementsInvalidated !== undefined) coerced.requirementsInvalidated = requirementsInvalidated.map((r) => {
       if (typeof r !== "string") return r;
       const [id, what] = splitPair(r);
       return { id, what };

package/src/resources/extensions/gsd/worktree-safety.ts

@@ -53,6 +53,7 @@ export interface WorktreeSafetyInput {
   projectRoot: string;
   unitRoot: string;
   milestoneId?: string | null;
+  isolationMode?: "none" | "branch" | "worktree";
   expectedBranch?: string | null;
   emptyWorktreeWithProjectContent?: boolean;
   lease?: {
@@ -156,12 +157,19 @@ export function createWorktreeSafetyModule(
 
       const projectRoot = resolve(input.projectRoot);
       const unitRoot = resolve(input.unitRoot);
-      const expectedRoot = join(projectRoot, ".gsd", "worktrees", milestoneId);
+      const isolationMode = input.isolationMode ?? "worktree";
+      const expectedRoot = isolationMode === "worktree"
+        ? join(projectRoot, ".gsd", "worktrees", milestoneId)
+        : projectRoot;
       if (!samePath(unitRoot, expectedRoot)) {
         return failure(
           "invalid-root",
-          `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`,
-          "Prepare the Unit in its canonical milestone worktree before allowing source writes.",
+          isolationMode === "worktree"
+            ? `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`
+            : `Unit root ${unitRoot} is not the project root while isolation mode is ${isolationMode}.`,
+          isolationMode === "worktree"
+            ? "Prepare the Unit in its canonical milestone worktree before allowing source writes."
+            : "Run the Unit from the project root when worktree isolation is disabled.",
           { expectedRoot, unitRoot },
         );
       }
@@ -197,7 +205,7 @@ export function createWorktreeSafetyModule(
         );
       }
 
-      if (!gitMarkerStat.isFile()) {
+      if (isolationMode === "worktree" && !gitMarkerStat.isFile()) {
         return failure(
           "worktree-git-marker-not-file",
           `Worktree root ${unitRoot} has a .git directory, not a registered worktree .git file.`,

package/src/resources/extensions/shared/next-action-ui.ts

@@ -118,11 +118,9 @@ export async function showNextAction(
 		}
 	});
 
-	// Headless guard: when no UI is bound (noOpUIContext), ctx.ui.custom() resolves
-	// to undefined immediately, and ctx.ui.select() does the same. Skip both and
-	// return the safe default so callers don't await two no-op promises before
-	// reaching a deterministic "not_yet". Lockup #5125 root protection.
-	if (!ctx.hasUI) {
+	// Headless/non-interactive guard: avoid emitting interactive select requests
+	// in contexts where no human can answer (no UI, RPC/headless shims).
+	if (!isInteractiveUIContext(ctx)) {
 		return "not_yet";
 	}
 
@@ -218,3 +216,11 @@ export async function showNextAction(
 
 	return result;
 }
+
+function isInteractiveUIContext(ctx: ExtensionCommandContext): boolean {
+	if (!ctx.hasUI) return false;
+	if (process.env.GSD_HEADLESS === "1") return false;
+	const uiMode = (ctx.ui as { mode?: string } | undefined)?.mode;
+	if (uiMode === "rpc" || uiMode === "headless") return false;
+	return true;
+}

package/src/resources/extensions/shared/tests/next-action-ui-hasui.test.ts

@@ -81,6 +81,38 @@ describe("showNextAction ctx.hasUI guard (#5125 lockup root protection)", () =>
     assert.equal(result, "alpha", "fallback should map the picked label back to the chosen action id");
   });
 
+  it("returns 'not_yet' immediately when UI mode is rpc even if ctx.hasUI is true", async () => {
+    let customCalled = 0;
+    let selectCalled = 0;
+
+    const ctx = {
+      hasUI: true,
+      ui: {
+        mode: "rpc",
+        custom: async () => {
+          customCalled++;
+          return undefined as never;
+        },
+        select: async () => {
+          selectCalled++;
+          return undefined;
+        },
+      },
+    };
+
+    const result = await showNextAction(ctx as any, {
+      title: "GSD — test",
+      actions: [
+        { id: "alpha", label: "Alpha", description: "first", recommended: true },
+        { id: "beta", label: "Beta", description: "second" },
+      ],
+    });
+
+    assert.equal(result, "not_yet", "rpc-backed UI is non-interactive for next-action");
+    assert.equal(customCalled, 0, "ctx.ui.custom must not be called in rpc mode");
+    assert.equal(selectCalled, 0, "ctx.ui.select must not be called in rpc mode");
+  });
+
   it("returns the resolved id when ctx.ui.custom completes normally", async () => {
     let selectCalled = 0;