gsd-pi 2.79.0-dev.bbb2f88ce → 2.79.0-dev.ece5fd8ba

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-b873eb2a8c4529c9
+76e1a0d39c0a27d8

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -166,7 +166,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         const { getEcosystemReadyPromise } = await import("../ecosystem/loader.js");
         await getEcosystemReadyPromise();
         const beforeAgentBasePath = process.cwd();
-        const pendingApprovalGate = getPendingGate();
+        const pendingApprovalGate = getPendingGate(beforeAgentBasePath);
         if (pendingApprovalGate && isExplicitApprovalResponse(event.prompt, pendingApprovalGate)) {
             markApprovalGateVerified(pendingApprovalGate, beforeAgentBasePath);
             const milestoneId = extractDepthVerificationMilestoneId(pendingApprovalGate);
@@ -363,15 +363,15 @@ export function registerHooks(pi, ecosystemHandlers) {
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
         // If ask_user_questions was called with a gate ID but hasn't been confirmed,
         // block all non-read-only tool calls to prevent the model from skipping gates.
-        if (getPendingGate()) {
+        if (getPendingGate(discussionBasePath)) {
             const milestoneId = await getDiscussionMilestoneIdFor(discussionBasePath);
             if (isToolCallEventType("bash", event)) {
-                const bashGuard = shouldBlockPendingGateBash(event.input.command, milestoneId, isQueuePhaseActive());
+                const bashGuard = shouldBlockPendingGateBash(event.input.command, milestoneId, isQueuePhaseActive(discussionBasePath), discussionBasePath);
                 if (bashGuard.block)
                     return bashGuard;
             }
             else {
-                const gateGuard = shouldBlockPendingGate(toolName, milestoneId, isQueuePhaseActive());
+                const gateGuard = shouldBlockPendingGate(toolName, milestoneId, isQueuePhaseActive(discussionBasePath), discussionBasePath);
                 if (gateGuard.block)
                     return gateGuard;
             }
@@ -380,7 +380,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         // When /gsd queue is active, the agent should only create milestones,
         // not execute work. Block write/edit to non-.gsd/ paths and bash commands
         // that would modify files.
-        if (isQueuePhaseActive()) {
+        if (isQueuePhaseActive(discussionBasePath)) {
             let queueInput = "";
             if (isToolCallEventType("write", event)) {
                 queueInput = event.input.path;
@@ -445,7 +445,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         if (!isToolCallEventType("write", event))
             return;
-        const result = shouldBlockContextWrite(event.toolName, event.input.path, await getDiscussionMilestoneIdFor(discussionBasePath), isQueuePhaseActive());
+        const result = shouldBlockContextWrite(event.toolName, event.input.path, await getDiscussionMilestoneIdFor(discussionBasePath), isQueuePhaseActive(discussionBasePath), discussionBasePath);
         if (result.block)
             return result;
     });
@@ -500,7 +500,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         const basePath = process.cwd();
         const milestoneId = await getDiscussionMilestoneIdFor(basePath);
-        const queueActive = isQueuePhaseActive();
+        const queueActive = isQueuePhaseActive(basePath);
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -508,7 +508,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         // If the user responded at all (even "needs adjustment"), clear the pending gate
         // because the user engaged — the prompt handles the re-ask-after-adjustment flow.
         const questions = event.input?.questions ?? [];
-        const currentPendingGate = getPendingGate();
+        const currentPendingGate = getPendingGate(basePath);
         if (currentPendingGate) {
             if (details?.cancelled || !details?.response) {
                 // Gate stays pending. Direct the agent to the most reliable recovery

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -298,8 +298,8 @@ export function getPendingGate(basePath = process.cwd()) {
  * Returns { block: true, reason } if the tool should be blocked.
  * ask_user_questions itself is allowed so the model can re-ask the gate.
  */
-export function shouldBlockPendingGate(toolName, milestoneId, queuePhaseActive) {
-    return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+export function shouldBlockPendingGate(toolName, milestoneId, queuePhaseActive, basePath = process.cwd()) {
+    return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(basePath), toolName, milestoneId, queuePhaseActive);
 }
 export function shouldBlockPendingGateInSnapshot(snapshot, toolName, _milestoneId, _queuePhaseActive) {
     if (!snapshot.pendingGateId)
@@ -322,8 +322,8 @@ export function shouldBlockPendingGateInSnapshot(snapshot, toolName, _milestoneI
  * Check whether a bash command should be blocked because a discussion gate is pending.
  * All bash is blocked while waiting for confirmation so the question stays visible.
  */
-export function shouldBlockPendingGateBash(command, milestoneId, queuePhaseActive) {
-    return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+export function shouldBlockPendingGateBash(command, milestoneId, queuePhaseActive, basePath = process.cwd()) {
+    return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(basePath), command, milestoneId, queuePhaseActive);
 }
 export function shouldBlockPendingGateBashInSnapshot(snapshot, command, _milestoneId, _queuePhaseActive) {
     if (!snapshot.pendingGateId)
@@ -363,7 +363,7 @@ export function isDepthConfirmationAnswer(selected, options) {
     // Returning false prevents any free-form string from unlocking the gate.
     return false;
 }
-export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queuePhaseActive) {
+export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queuePhaseActive, basePath = process.cwd()) {
     if (toolName !== "write")
         return { block: false };
     if (!MILESTONE_CONTEXT_RE.test(inputPath))
@@ -379,7 +379,7 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queue
             ].join(" "),
         };
     }
-    if (isMilestoneDepthVerified(targetMilestoneId))
+    if (isMilestoneDepthVerified(targetMilestoneId, basePath))
         return { block: false };
     return {
         block: true,
@@ -397,8 +397,8 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queue
  * Slice-level CONTEXT artifacts are allowed; milestone-level CONTEXT writes
  * require the milestone to be depth-verified first.
  */
-export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceId) {
-    return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceId, basePath = process.cwd()) {
+    return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(basePath), artifactType, milestoneId, sliceId);
 }
 export function shouldBlockContextArtifactSaveInSnapshot(snapshot, artifactType, milestoneId, sliceId) {
     if (artifactType !== "CONTEXT")

package/dist/resources/extensions/gsd/guided-flow.js

@@ -44,6 +44,7 @@ import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
+import { getPendingGate, extractDepthVerificationMilestoneId } from "./bootstrap/write-gate.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -295,6 +296,14 @@ export async function checkDeepProjectSetupAfterTurn(_event, ctx, basePath) {
             return false;
         }
     }
+    // R2: a depth-verification gate is still pending — the LLM emitted the
+    // confirmation question (via ask_user_questions or plain chat) but the user
+    // has not approved yet. Returning false keeps the entry in the
+    // pendingDeepProjectSetupMap so the next user message can resume.
+    const pendingGateId = getPendingGate(entry.basePath);
+    if (pendingGateId) {
+        return false;
+    }
     return dispatchNextDeepProjectSetupStage(entry);
 }
 async function dispatchNextDeepProjectSetupStage(entry) {
@@ -368,6 +377,23 @@ export function checkAutoStartAfterDiscuss() {
     const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
     if (!contextFile && !roadmapFile)
         return false; // neither artifact yet — keep waiting
+    // Gate 1a: a depth-verification gate is still pending for THIS milestone — the
+    // LLM emitted the confirmation question (via ask_user_questions or plain chat)
+    // but the user has not answered yet. Advancing now would skip the gate and
+    // race ahead with unverified context.
+    const basePathForGate = entry.scope.workspace.projectRoot;
+    const pendingGateId = getPendingGate(basePathForGate);
+    if (pendingGateId) {
+        const pendingMilestoneId = extractDepthVerificationMilestoneId(pendingGateId);
+        // Block advancement if the gate is for THIS milestone, OR if it's a
+        // project/requirements gate (no milestone id encoded) for the deep setup flow.
+        const isProjectGate = pendingGateId === "depth_verification_project_confirm" ||
+            pendingGateId === "depth_verification_requirements_confirm" ||
+            pendingGateId === "depth_verification_research_decision_confirm";
+        if (pendingMilestoneId === milestoneId || isProjectGate) {
+            return false;
+        }
+    }
     // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
     // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
     // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
@@ -489,6 +515,20 @@ export function checkAutoStartAfterDiscuss() {
             logWarning("guided", `manifest unlink failed: ${e.message}`);
         }
     }
+    // R3b: belt-and-suspenders for silent registration failure. The discuss flow
+    // finished and STATE.md exists, but the milestone may never have landed in
+    // the DB. Without this guard, the user sees "Milestone M001 ready." and then
+    // /gsd reports "No Active Milestone".
+    if (isDbAvailable()) {
+        const milestoneRow = getMilestone(milestoneId);
+        if (!milestoneRow) {
+            ctx.ui.notify(`Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+                `PROJECT.md may have failed to register milestones. ` +
+                `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+                `then re-run /gsd to recover.`, "error");
+            return false;
+        }
+    }
     pendingAutoStartMap.delete(basePath);
     ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
     startAutoDetached(ctx, pi, basePath, false, { step });

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -141,7 +141,6 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             task_id: isRootArtifact ? undefined : params.task_id,
         }, basePath);
         let registeredMilestones = [];
-        let registrationWarning;
         if (params.artifact_type === "PROJECT") {
             try {
                 registeredMilestones = registerProjectMilestoneSequence(contentToSave);
@@ -150,12 +149,55 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                registrationWarning = `PROJECT artifact saved, but milestone registration failed: ${msg}`;
-                logWarning("tool", registrationWarning, {
+                logError("tool", `gsd_summary_save: PROJECT artifact persisted but milestone registration threw: ${msg}`, {
                     tool: "gsd_summary_save",
                     error: String(err),
                     stack: err instanceof Error ? err.stack ?? "" : "",
                 });
+                // PROJECT.md was persisted by saveArtifactToDb above; the artifacts row
+                // changed even though no milestones registered. Invalidate so subsequent
+                // /gsd reads see the persisted artifact instead of the pre-save cache.
+                invalidateStateCache();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: PROJECT.md was saved to ${relativePath} but milestone registration failed: ${msg}. ` +
+                                `The DB has no milestone rows for this project, so /gsd will report "No Active Milestone". ` +
+                                `Re-call gsd_summary_save(PROJECT) once the underlying error is resolved — INSERT OR IGNORE makes registration idempotent.`,
+                        }],
+                    details: {
+                        operation: "save_summary",
+                        path: relativePath,
+                        artifact_type: params.artifact_type,
+                        error: "milestone_registration_threw",
+                        registration_error: msg,
+                    },
+                    isError: true,
+                };
+            }
+            if (registeredMilestones.length === 0) {
+                logError("tool", `gsd_summary_save: PROJECT.md saved to ${relativePath} but parsed zero milestones — registration produced no DB rows`, {
+                    tool: "gsd_summary_save",
+                });
+                // PROJECT.md was persisted; invalidate so subsequent reads see the new
+                // artifacts row even though no milestones registered.
+                invalidateStateCache();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: PROJECT.md was saved to ${relativePath} but contains zero parseable milestone lines, ` +
+                                `so no milestones were registered in the DB. /gsd will report "No Active Milestone". ` +
+                                `Rewrite PROJECT.md so the "Milestone Sequence" section uses canonical lines: ` +
+                                `\`- [ ] M001: <Title> — <One-liner>\` (em-dash, double-dash \`--\`, or single-dash \`-\` separator), then re-call gsd_summary_save(PROJECT).`,
+                        }],
+                    details: {
+                        operation: "save_summary",
+                        path: relativePath,
+                        artifact_type: params.artifact_type,
+                        error: "milestone_registration_empty_parse",
+                    },
+                    isError: true,
+                };
             }
         }
         if (params.artifact_type === "CONTEXT" && !params.task_id) {
@@ -178,7 +220,6 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
                 artifact_type: params.artifact_type,
                 content_source: contentSource,
                 ...(registeredMilestones.length > 0 ? { registeredMilestones } : {}),
-                ...(registrationWarning ? { warning: registrationWarning } : {}),
             },
         };
     }