@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.844675c9

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -22,6 +22,7 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeInlinedContext, composeUnitContext } from "./unit-context-composer.js";
+import { resolveManifest } from "./unit-context-manifest.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
@@ -1451,6 +1452,75 @@ export async function buildDiscussRequirementsPrompt(base, structuredQuestionsAv
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
     }));
 }
+/**
+ * Bounded codebase snapshot for research-milestone grounding (ADR-029).
+ *
+ * Reuses the in-process, ~millisecond `analyzeCodebase` / `formatCodebaseBrief`
+ * machinery that powers the guided-discuss Preparation Snapshot, so research
+ * grounds on current code reality instead of running an open-ended `rg`/`find`/
+ * `scout` survey on every dispatch (the auto-mode counterpart to ADR-028).
+ *
+ * Gated on the manifest's `codebaseMap` flag (previously a dead policy flag)
+ * and the `discuss_preparation` opt-out. Failures degrade silently — research
+ * still runs, it just falls back to on-demand reads.
+ */
+async function buildResearchCodebaseSnapshot(base) {
+    const manifest = resolveManifest("research-milestone");
+    if (!manifest?.codebaseMap)
+        return null;
+    const prefs = loadEffectiveGSDPreferences(base)?.preferences;
+    if (prefs?.discuss_preparation === false)
+        return null;
+    try {
+        const { analyzeCodebase, formatCodebaseBrief } = await import("./preparation.js");
+        const brief = await analyzeCodebase(base);
+        const formatted = formatCodebaseBrief(brief).trim();
+        if (!formatted)
+            return null;
+        return [
+            "### Codebase Snapshot (current code reality)",
+            "Source: in-process bounded scan of the working tree.",
+            "",
+            "This snapshot describes what already exists. Treat it as authoritative for current code reality and do NOT re-survey the tree to rediscover it. Read a specific file only when a research question hinges on its exact contents.",
+            "",
+            formatted,
+        ].join("\n");
+    }
+    catch (err) {
+        logWarning("prompt", `buildResearchCodebaseSnapshot failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Lightweight research resume block (ADR-029).
+ *
+ * When a prior attempt for this milestone left durable output — a partial
+ * RESEARCH artifact and/or a research phase anchor — inline it under a
+ * "continue, do not redo" banner so a re-dispatched research unit extends
+ * prior work instead of re-running every command from scratch (the
+ * restart-from-scratch pattern observed in the 789 run trace). No new state
+ * machine: the partial RESEARCH file and the existing phase anchor are the
+ * durable signals. Returns null when there is nothing to resume.
+ */
+async function buildResearchResumeBlock(base, mid) {
+    const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
+    const researchRel = relMilestoneFile(base, mid, "RESEARCH");
+    const partial = await inlineFileOptional(researchPath, researchRel, "Prior Partial Research");
+    const anchor = readPhaseAnchor(base, mid, "research-milestone");
+    if (!partial && !anchor)
+        return null;
+    const lines = [
+        "### Resume — Prior Partial Research (continue, do not redo)",
+        "",
+        "A previous research attempt for this milestone left the durable output below. **Build on it — do not restart from scratch.** Re-run a command only when its prior result is missing or stale, and persist progress incrementally with `gsd_summary_save` so any interruption keeps your findings.",
+        "",
+    ];
+    if (anchor)
+        lines.push(formatAnchorForPrompt(anchor), "");
+    if (partial)
+        lines.push(partial);
+    return lines.join("\n").trimEnd();
+}
 export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     const contextTelemetry = [];
     // Keep research milestone prompts focused on the milestone brief and
@@ -1490,6 +1560,32 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     const parts = [];
     if (composed.prepend)
         parts.push(composed.prepend);
+    // Resume grounding (ADR-029): if a prior attempt left partial research or a
+    // phase anchor, inline it prominently so a re-dispatched unit continues
+    // rather than re-running every command from scratch.
+    const resumeBlock = await buildResearchResumeBlock(base, mid);
+    if (resumeBlock) {
+        parts.push(resumeBlock);
+        trackPromptContext(contextTelemetry, "research-resume", "inline", resumeBlock);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "research-resume", "skipped", null, "no prior partial research");
+    }
+    // Project-size signal (ADR-029): same classification plan-milestone gets, so
+    // research right-sizes effort on tiny projects instead of over-researching.
+    const classificationBlock = formatProjectClassificationForPlanning(classifyProject(base));
+    parts.push(classificationBlock);
+    trackPromptContext(contextTelemetry, "project-classification", "inline", classificationBlock);
+    // Codebase snapshot (ADR-029): bounded, in-process code-reality grounding so
+    // research does not open-endedly survey the tree (auto-mode ADR-028).
+    const codebaseSnapshot = await buildResearchCodebaseSnapshot(base);
+    if (codebaseSnapshot) {
+        parts.push(codebaseSnapshot);
+        trackPromptContext(contextTelemetry, "codebase-snapshot", "inline", codebaseSnapshot);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "codebase-snapshot", "skipped", null, "disabled, empty, or scan failed");
+    }
     if (knowledgeInlineRM && composed.inline) {
         const idx = composed.inline.lastIndexOf("### Output Template:");
         if (idx > 0) {
@@ -3190,6 +3286,17 @@ opts) {
 // gate-registry.ts so that prompt builders, dispatch rules, state
 // derivation, and tool handlers all consult the same source of truth.
 // See gate-registry.ts for the full ownership map.
+/**
+ * Adapt gate-registry guidance for section-close phases.
+ *
+ * Gate-registry text is shared with the gate-evaluate subagent, where
+ * "Return verdict ..." is literal. Section-close units write artifact sections
+ * instead, so translate that wording at render time without mutating the
+ * canonical guidance.
+ */
+function sectionModeGuidance(guidance) {
+    return guidance.replace(/Return verdict '([^']+)'/g, (_match, verdict) => verdict === "omitted" ? "Leave the section empty" : `Record a \`${verdict}\``);
+}
 /**
  * Render a "Gates to Close" block for turns like `complete-slice` and
  * `validate-milestone` that own gates which are closed as a side-effect
@@ -3208,12 +3315,14 @@ function renderGatesToCloseBlock(gates, opts) {
     lines.push("");
     lines.push("These quality gates are still pending for this unit. You MUST address every one before calling the closing tool — the handler closes the DB row based on whether the corresponding artifact section is present.");
     lines.push("");
+    lines.push("**Do NOT call `gsd_save_gate_result` (or any gate-result tool) for these gates** — that tool belongs to a different phase and the call will be blocked. You close each gate purely by writing its named section: a populated section records `pass`, an empty section records `omitted`, and the completion handler persists the verdict for you. Treat any \"return verdict\" wording in the guidance below as describing that section outcome, not as an instruction to call a tool.");
+    lines.push("");
     for (const def of applicable) {
         lines.push(`### ${def.id} — ${def.promptSection}`);
         lines.push("");
         lines.push(`**Question:** ${def.question}`);
         lines.push("");
-        lines.push(def.guidance);
+        lines.push(sectionModeGuidance(def.guidance));
         if (opts.allowOmit) {
             lines.push("");
             lines.push(`If this gate genuinely does not apply to this unit, leave the **${def.promptSection}** section empty and the handler will record it as \`omitted\`. Otherwise, fill the section with concrete evidence.`);

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -23,6 +23,9 @@ export function isAutoPaused() {
 export function isAutoCompletionStopInProgress() {
     return autoSession.completionStopInProgress;
 }
+export function clearAutoCompletionStopInProgress() {
+    autoSession.completionStopInProgress = false;
+}
 export function markToolStart(toolCallId, toolName) {
     markTrackedToolStart(toolCallId, autoSession.active, toolName);
 }

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -123,6 +123,11 @@ export const DETERMINISTIC_POLICY_ERROR_STRINGS = [
     // "Cannot write to milestone CONTEXT.md without depth verification." for direct
     // write tool calls to *-CONTEXT.md paths (different code path than gsd_summary_save).
     "CONTEXT.md without depth verification",
+    // Section-close gate units (execute-task, complete-slice, validate-milestone) that
+    // reach for gsd_save_gate_result get the calm redirect from softGateToolRedirect
+    // (auto-unit-tool-scope.ts) instead of a HARD BLOCK. Still deterministic — those
+    // phases never own that tool, so a retry hits the same redirect every time.
+    "closes its quality gates by writing summary sections",
 ];
 /**
  * Returns true if the error message indicates a deterministic policy gate

package/dist/resources/extensions/gsd/auto-unit-tool-scope.js

@@ -25,6 +25,16 @@ const EXECUTE_TASK_UNIT_TYPES = new Set([
     "execute-task-simple",
     "reactive-execute",
 ]);
+// These units own quality gates, but their completion handlers persist verdicts
+// from artifact sections. gsd_save_gate_result belongs to gate-evaluate, so keep
+// blocking it here with a calm redirect to the section-write path.
+const SECTION_CLOSE_GATE_UNIT_TYPES = new Set([
+    "execute-task",
+    "execute-task-simple",
+    "reactive-execute",
+    "complete-slice",
+    "validate-milestone",
+]);
 const EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS = [
     "gsd_skip_slice",
     "gsd_slice_reopen",
@@ -38,6 +48,7 @@ const SCOPED_GSD_LIFECYCLE_TOOLS = new Set([
     .filter((tool) => tool.startsWith("gsd_"))
     .map(canonicalWorkflowToolName));
 export const GSD_PHASE_SCOPE_DISPLAY_REASON = "This GSD phase only allows its scoped workflow tools.";
+export const GSD_SECTION_CLOSE_GATE_DISPLAY_REASON = "Gates here close by writing summary sections — gsd_save_gate_result isn't needed.";
 function stripMcpToolPrefix(toolName) {
     if (!toolName.startsWith("mcp__"))
         return toolName;
@@ -65,6 +76,21 @@ function hardBlock(unitType, what) {
         displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
     };
 }
+// This stable marker is registered in auto-tool-tracking.ts so auto-mode treats
+// the redirect as deterministic policy, not a retryable execution failure.
+function softGateToolRedirect(unitType) {
+    return {
+        block: true,
+        reason: [
+            `Skip this call — the "${unitType}" phase closes its quality gates by writing summary sections,`,
+            "not by calling gsd_save_gate_result (that tool belongs to the gate-evaluate phase).",
+            "Record each gate by filling its named section in your summary: a populated section records `pass`,",
+            "an empty one records `omitted`. Then call your completion tool and the handler persists every verdict.",
+            "This is expected, not an error — continue without gsd_save_gate_result.",
+        ].join(" "),
+        displayReason: GSD_SECTION_CLOSE_GATE_DISPLAY_REASON,
+    };
+}
 function allowedGsdToolsForUnit(unitType) {
     return [...new Set((AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [])
             .filter((tool) => tool.startsWith("gsd_"))
@@ -122,5 +148,8 @@ export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     if (forbiddenReason) {
         return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; ${forbiddenReason} Fix unit-tool-contracts.ts or the ${unitType} prompt.`);
     }
+    if (canonicalTool === "gsd_save_gate_result" && SECTION_CLOSE_GATE_UNIT_TYPES.has(unitType)) {
+        return softGateToolRedirect(unitType);
+    }
     return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`);
 }

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

@@ -25,7 +25,7 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { classifyProject } from "./detection.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, nativeLsFiles, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeMergeRegular, nativeConflictFiles, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, nativeLsFiles, } from "./native-git-bridge.js";
 import { CLOSEOUT_CONSISTENCY_BLOCKED_REASON, checkCloseoutConsistencyGate, formatCloseoutConsistencyBlock, } from "./closeout-consistency-gate.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace } from "./workspace.js";
@@ -438,16 +438,17 @@ function removeMergeStateFiles(basePath, contextLabel) {
         logError("worktree", `${contextLabel} merge state cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-function cleanupSquashConflictState(basePath) {
-    // `git merge --squash` conflicts can leave unmerged index entries without
-    // MERGE_HEAD, so merge-abort alone is not enough. Reset the merge index, then
-    // remove merge message files that native/libgit2 paths may have created.
+function cleanupConflictState(basePath) {
+    // Merge conflicts can leave unmerged index entries; merge-abort alone is not
+    // enough for squash merges (MERGE_HEAD is never written). Reset the merge
+    // index, then remove merge message files that native/libgit2 paths may have
+    // created.
     try {
         nativeMergeAbort(basePath);
     }
     catch (err) {
-        // Expected for squash conflicts when MERGE_HEAD was never written.
-        debugLog("squash-conflict-cleanup:merge-abort-skipped", {
+        // MERGE_HEAD absent (squash merge path) — abort is a no-op, which is fine.
+        debugLog("conflict-cleanup:merge-abort-skipped", {
             error: err instanceof Error ? err.message : String(err),
         });
     }
@@ -459,9 +460,9 @@ function cleanupSquashConflictState(basePath) {
         });
     }
     catch (err) {
-        logError("worktree", `git reset --merge failed after squash conflict: ${err instanceof Error ? err.message : String(err)}`);
+        logError("worktree", `git reset --merge failed after merge conflict: ${err instanceof Error ? err.message : String(err)}`);
     }
-    removeMergeStateFiles(basePath, "squash conflict");
+    removeMergeStateFiles(basePath, "conflict");
 }
 // ─── Dispatch-Level Sync (project root ↔ worktree) ──────────────────────────
 /**
@@ -1871,14 +1872,20 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         // report the dirty tree if it fails.
         logWarning("worktree", `git stash failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    // 7b. Clean up stale merge state before attempting squash merge (#2912).
+    // 7b. Clean up stale merge state before attempting the merge (#2912).
     // A leftover MERGE_HEAD (from a previous failed merge, libgit2 native path,
-    // or interrupted operation) causes `git merge --squash` to refuse with
+    // or interrupted operation) causes git merge to refuse with
     // "fatal: You have not concluded your merge (MERGE_HEAD exists)".
     // Defensively remove merge artifacts before starting.
     removeMergeStateFiles(originalBasePath_, "pre-merge");
-    // 8. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
-    const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
+    // 8. Merge — respect merge_strategy preference (#549).
+    // "squash" (default): stages changes without a merge commit; caller commits.
+    // "merge": --no-ff --no-commit so caller can supply the commit message while
+    // git records a real merge commit (MERGE_HEAD present when nativeCommit runs).
+    const effectiveStrategy = prefs.merge_strategy === "merge" ? "merge" : "squash";
+    const mergeResult = effectiveStrategy === "merge"
+        ? nativeMergeRegular(originalBasePath_, milestoneBranch)
+        : nativeMergeSquash(originalBasePath_, milestoneBranch);
     if (needsDbCycle && dbPathToReopen) {
         try {
             openDatabase(dbPathToReopen);
@@ -1912,7 +1919,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             const fileList = mergeResult.dirtyFiles?.length
                 ? `Dirty files:\n${mergeResult.dirtyFiles.map((f) => `  ${f}`).join("\n")}`
                 : `Check \`git status\` in the project root for details.`;
-            throw new GSDError(GSD_GIT_ERROR, `Squash merge of ${milestoneBranch} rejected: working tree has dirty or untracked files ` +
+            throw new GSDError(GSD_GIT_ERROR, `${effectiveStrategy === "merge" ? "Merge" : "Squash merge"} of ${milestoneBranch} rejected: working tree has dirty or untracked files ` +
                 `that conflict with the merge. ${fileList}`);
         }
         // Check for conflicts — use merge result first, fall back to nativeConflictFiles
@@ -1930,7 +1937,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             }
             // If there are still real code conflicts, escalate
             if (codeConflicts.length > 0) {
-                cleanupSquashConflictState(originalBasePath_);
+                cleanupConflictState(originalBasePath_);
                 // Pop stash before throwing so local work is not lost (#2151).
                 if (stashed) {
                     try {
@@ -1947,7 +1954,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 // causing autoCommitDirtyState to commit unrelated milestone files to
                 // the integration branch (#2929).
                 process.chdir(previousCwd);
-                throw new MergeConflictError(codeConflicts, "squash", milestoneBranch, mainBranch);
+                throw new MergeConflictError(codeConflicts, effectiveStrategy, milestoneBranch, mainBranch);
             }
         }
         // No conflicts detected — possibly "already up to date", fall through to commit
@@ -2096,7 +2103,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         if (codeChanges.length > 0) {
             // Milestone has unanchored code changes — abort teardown.
             process.chdir(previousCwd);
-            throw new GSDError(GSD_GIT_ERROR, `Squash merge produced nothing to commit but milestone branch "${milestoneBranch}" ` +
+            throw new GSDError(GSD_GIT_ERROR, `${effectiveStrategy === "merge" ? "Merge" : "Squash merge"} produced nothing to commit but milestone branch "${milestoneBranch}" ` +
                 `has ${codeChanges.length} code file(s) not on "${mainBranch}". ` +
                 `Aborting worktree teardown to prevent data loss.`);
         }