@opengsd/gsd-pi 1.1.1-dev.154fd443 → 1.1.1-dev.1854a79a

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

@@ -3190,6 +3190,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 +3219,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)"}`);
 }