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

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -181,6 +181,31 @@ function renderUatMarkdown(params) {
 ${params.uatContent}
 `;
 }
+function parseRequirementSection(summaryMd, heading, field) {
+    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 !== null);
+}
 /**
  * Handle the complete_slice operation end-to-end.
  *
@@ -216,6 +241,7 @@ export async function handleCompleteSlice(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = null;
+    let existingSummaryMd = "";
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
@@ -226,6 +252,7 @@ export async function handleCompleteSlice(params, basePath) {
             return;
         }
         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__";
@@ -270,8 +297,29 @@ export async function handleCompleteSlice(params, basePath) {
     if (guardError) {
         return { error: guardError };
     }
+    const effectiveParams = { ...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;
+        }
+        if (effectiveParams.requirementsValidated === undefined) {
+            const parsed = parseRequirementSection(existingSummaryMd, "Requirements Validated", "proof");
+            if (parsed.length > 0)
+                effectiveParams.requirementsValidated = parsed;
+        }
+        if (effectiveParams.requirementsInvalidated === undefined) {
+            const parsed = parseRequirementSection(existingSummaryMd, "Requirements Invalidated or Re-scoped", "what");
+            if (parsed.length > 0)
+                effectiveParams.requirementsInvalidated = parsed;
+        }
+    }
     // Render summary markdown
-    const summaryMd = renderSliceSummaryMarkdown(params);
+    const summaryMd = renderSliceSummaryMarkdown(effectiveParams);
     // Resolve and write summary to disk
     let summaryPath;
     const sliceDir = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
@@ -285,7 +333,7 @@ export async function handleCompleteSlice(params, basePath) {
         mkdirSync(manualSliceDir, { recursive: true });
         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/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -407,46 +407,72 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
             const m = s.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
             return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
         };
-        const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
-        const coerced = { ...params };
-        coerced.provides = wrapArray(params.provides);
-        coerced.keyFiles = wrapArray(params.keyFiles);
-        coerced.keyDecisions = wrapArray(params.keyDecisions);
-        coerced.patternsEstablished = wrapArray(params.patternsEstablished);
-        coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
-        coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
-        coerced.drillDownPaths = wrapArray(params.drillDownPaths);
-        coerced.affects = wrapArray(params.affects);
-        coerced.filesModified = wrapArray(params.filesModified).map((f) => {
-            if (typeof f !== "string")
-                return f;
-            const [path, description] = splitPair(f);
-            return { path, description };
-        });
-        coerced.requires = wrapArray(params.requires).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [slice, provides] = splitPair(r);
-            return { slice, provides };
-        });
-        coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, how] = splitPair(r);
-            return { id, how };
-        });
-        coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, proof] = splitPair(r);
-            return { id, proof };
-        });
-        coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, what] = splitPair(r);
-            return { id, what };
-        });
+        const wrapOptionalArray = (v) => v == null ? undefined : Array.isArray(v) ? v : [v];
+        const coerced = Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined && value !== null));
+        const provides = wrapOptionalArray(params.provides);
+        if (provides !== undefined)
+            coerced.provides = provides;
+        const keyFiles = wrapOptionalArray(params.keyFiles);
+        if (keyFiles !== undefined)
+            coerced.keyFiles = keyFiles;
+        const keyDecisions = wrapOptionalArray(params.keyDecisions);
+        if (keyDecisions !== undefined)
+            coerced.keyDecisions = keyDecisions;
+        const patternsEstablished = wrapOptionalArray(params.patternsEstablished);
+        if (patternsEstablished !== undefined)
+            coerced.patternsEstablished = patternsEstablished;
+        const observabilitySurfaces = wrapOptionalArray(params.observabilitySurfaces);
+        if (observabilitySurfaces !== undefined)
+            coerced.observabilitySurfaces = observabilitySurfaces;
+        const requirementsSurfaced = wrapOptionalArray(params.requirementsSurfaced);
+        if (requirementsSurfaced !== undefined)
+            coerced.requirementsSurfaced = requirementsSurfaced;
+        const drillDownPaths = wrapOptionalArray(params.drillDownPaths);
+        if (drillDownPaths !== undefined)
+            coerced.drillDownPaths = drillDownPaths;
+        const affects = wrapOptionalArray(params.affects);
+        if (affects !== undefined)
+            coerced.affects = affects;
+        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 };
+            });
+        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 };
+            });
+        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 };
+            });
+        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 };
+            });
+        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 };
+            });
         const result = await handleCompleteSlice(coerced, basePath);
         if ("error" in result) {
             return {

package/dist/resources/extensions/gsd/worktree-safety.js

@@ -58,9 +58,16 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
             }
             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.", { expectedRoot, unitRoot });
+                return failure("invalid-root", 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 });
             }
             if (!deps.existsSync(unitRoot)) {
                 return failure("worktree-missing", `Worktree root ${unitRoot} does not exist.`, "Create or recover the milestone worktree before dispatching the source-writing Unit.", { unitRoot });
@@ -76,7 +83,7 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
             catch (error) {
                 return failure("worktree-git-probe-failed", `Unable to inspect .git marker for worktree root ${unitRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { gitMarker, error: errorMessage(error) });
             }
-            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.`, "Use a registered GSD worktree instead of a copied or nested repository.", { gitMarker });
             }
             let registered;

package/dist/resources/extensions/shared/next-action-ui.js

@@ -63,11 +63,9 @@ export async function showNextAction(ctx, opts) {
             return f;
         }
     });
-    // 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";
     }
     const result = await ctx.ui.custom((_tui, theme, _kb, done) => {
@@ -173,3 +171,13 @@ export async function showNextAction(ctx, opts) {
     }
     return result;
 }
+function isInteractiveUIContext(ctx) {
+    if (!ctx.hasUI)
+        return false;
+    if (process.env.GSD_HEADLESS === "1")
+        return false;
+    const uiMode = ctx.ui?.mode;
+    if (uiMode === "rpc" || uiMode === "headless")
+        return false;
+    return true;
+}