@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

package/dist/resources/extensions/gsd/undo.js

@@ -9,10 +9,11 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
+import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveSliceFile, resolveTaskFile, buildTaskFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
+import { UNIT_REGISTRY } from "./unit-registry.js";
 /**
  * Undo the last completed unit: revert git commits,
  * delete summary artifacts, and uncheck the task in PLAN.
@@ -35,15 +36,19 @@ export async function handleUndo(args, ctx, _pi, basePath) {
         ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
         return;
     }
-    // Extract unit type and ID from the most recent activity log filename
-    // Format: <seq>-<unitType>-<unitId>.jsonl
-    const match = files[0].match(/^\d+-(.+?)-(.+)\.jsonl$/);
-    if (!match) {
+    // Extract unit type and ID from the most recent activity log filename.
+    // Both the unit type and the unit ID may contain hyphens, so anchor on the
+    // known unit-type vocabulary instead of guessing the unit-ID shape: a regex
+    // tuned to milestone-shaped IDs rejects project-level units whose IDs are
+    // symbolic (e.g. discuss-project uses PROJECT, workflow-preferences uses
+    // WORKFLOW-PREFS).
+    const parsed = parseActivityLogFilename(files[0]);
+    if (!parsed) {
         ctx.ui.notify("Nothing to undo — could not parse latest activity log.", "warning");
         return;
     }
-    const unitType = match[1];
-    const unitId = match[2].replace(/-/g, "/");
+    const unitType = parsed.unitType;
+    const unitId = parsed.unitId.replace(/-/g, "/");
     if (!force) {
         ctx.ui.notify(`Will undo: ${unitType} (${unitId})\n` +
             `This will:\n` +
@@ -87,6 +92,11 @@ export async function handleUndo(args, ctx, _pi, basePath) {
     if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
         const [mid, sid, tid] = [milestone, slice, task];
         planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
+        if (getTask(mid, sid, tid)) {
+            updateTaskStatus(mid, sid, tid, "pending");
+            await renderPlanCheckboxes(basePath, mid, sid);
+            planUpdated = true;
+        }
     }
     // 3. Try to revert git commits from activity log
     let commitsReverted = 0;
@@ -291,15 +301,14 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
         }
     }
     // Delete slice summary and UAT files
+    // Use resolveSliceFile so the legacy S01-SUMMARY.md filename is found even
+    // when buildSliceFileName now returns the flat-phase 01-SUMMARY.md format.
     let sliceFilesDeleted = 0;
-    const slicePath = resolveSlicePath(basePath, mid, sid);
-    if (slicePath) {
-        for (const suffix of ["SUMMARY", "UAT"]) {
-            const filePath = join(slicePath, buildSliceFileName(sid, suffix));
-            if (existsSync(filePath)) {
-                unlinkSync(filePath);
-                sliceFilesDeleted++;
-            }
+    for (const suffix of ["SUMMARY", "UAT"]) {
+        const filePath = resolveSliceFile(basePath, mid, sid, suffix);
+        if (filePath && existsSync(filePath)) {
+            unlinkSync(filePath);
+            sliceFilesDeleted++;
         }
     }
     // Re-render plan + roadmap checkboxes
@@ -319,6 +328,33 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
     ctx.ui.notify(results.join("\n"), "success");
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
+// Known unit types sorted longest-first so a more specific type (e.g.
+// "execute-task-simple") matches before a prefix of it ("execute-task") when
+// splitting "<seq>-<unitType>-<unitId>.jsonl".
+const UNIT_TYPES_BY_LENGTH_DESC = Object.keys(UNIT_REGISTRY).sort((a, b) => b.length - a.length);
+/**
+ * Parse an activity-log filename of the form `<seq>-<unitType>-<unitId>.jsonl`
+ * (the format written by activity-log.ts). Both the unit type and the unit ID
+ * may contain hyphens, so we anchor on the known unit-type vocabulary rather
+ * than guessing the ID shape. This keeps non-milestone IDs (e.g. PROJECT,
+ * WORKFLOW-PREFS) parseable. Returns null when the name has no sequence prefix
+ * or does not start with a recognised unit type.
+ */
+export function parseActivityLogFilename(filename) {
+    const seqMatch = filename.match(/^\d+-(.+)\.jsonl$/);
+    if (!seqMatch)
+        return null;
+    const rest = seqMatch[1];
+    for (const unitType of UNIT_TYPES_BY_LENGTH_DESC) {
+        const prefix = `${unitType}-`;
+        if (rest.startsWith(prefix)) {
+            const unitId = rest.slice(prefix.length);
+            if (unitId.length > 0)
+                return { unitType, unitId };
+        }
+    }
+    return null;
+}
 export function uncheckTaskInPlan(basePath, mid, sid, tid) {
     const slicePath = resolveSlicePath(basePath, mid, sid);
     if (!slicePath)

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -92,13 +92,27 @@ const CONTEXT_MODE_GUIDANCE_BY_LANE = {
     orchestration: "Use `gsd_resume` before resuming orchestration, `gsd_exec_search` to reuse prior runs, and `gsd_exec` for noisy coordination checks.",
     docs: "Use `gsd_resume` for prior context, `gsd_exec_search` for saved evidence, and `gsd_exec` for noisy doc validation commands.",
 };
-// Per-unit overrides win over the lane default. run-uat's tool contract
-// forbids `gsd_exec`/`gsd_exec_search` (acceptance evidence must flow through
-// `gsd_uat_exec`) and Claude Code dispatch strips the tools entirely, so the
-// shared verification-lane guidance would steer the agent into calling an
-// unavailable tool.
-const CONTEXT_MODE_GUIDANCE_BY_UNIT = {
+// Per-unit overrides win over the lane default. Some units intentionally run
+// with narrower tool contracts than their shared Context Mode lane, so their
+// guidance must name only tools the unit can actually call.
+export const CONTEXT_MODE_GUIDANCE_BY_UNIT = {
+    "discuss-milestone": "Use `ask_user_questions` to continue the milestone interview, then persist outcomes with `gsd_summary_save`, `gsd_decision_save`, `gsd_requirement_save`, `gsd_requirement_update`, `gsd_plan_milestone`, or `gsd_milestone_generate_id` as appropriate.",
+    "discuss-slice": "Use `ask_user_questions` to continue the slice interview, then persist outcomes with `gsd_summary_save` or `gsd_decision_save` as appropriate.",
+    "discuss-project": "Use `ask_user_questions` to continue the project interview, then persist outcomes with `gsd_summary_save`, `gsd_decision_save`, or `gsd_requirement_save` as appropriate.",
+    "discuss-requirements": "Use `ask_user_questions` to continue the requirements interview, then persist outcomes with `gsd_requirement_save` or `gsd_summary_save` as appropriate.",
+    "replan-slice": "Use `gsd_replan_slice` to persist the revised slice plan, and `gsd_decision_save` for planning decisions that need durable rationale.",
+    "reassess-roadmap": "Use `gsd_milestone_status` to inspect current milestone state, then `gsd_reassess_roadmap` to persist the roadmap reassessment.",
     "run-uat": "Use `gsd_uat_exec` for acceptance checks so evidence is typed as UAT-owned, and `gsd_resume` after compaction or resume.",
+    "research-project": "Dispatch parallel scout subagents for stack, features, architecture, and pitfalls research; each writes one file under `.gsd/research/` (`STACK.md`, `FEATURES.md`, `ARCHITECTURE.md`, `PITFALLS.md`).",
+    "gate-evaluate": "Use `subagent` to dispatch tester agents, then persist each gate with `gsd_save_gate_result`; rely on testers for verification evidence.",
+};
+// Per-unit guidance for the nested render mode (renderMode: "nested"), used when this
+// unit's Context Mode line is embedded into a subagent prompt — e.g. the tester prompts
+// dispatched by gate-evaluate. Must instruct the subagent on what IT should do, not
+// re-state the parent coordinator's dispatch instructions. Falls back to
+// CONTEXT_MODE_GUIDANCE_BY_UNIT then the lane default when no nested entry exists.
+export const CONTEXT_MODE_NESTED_GUIDANCE_BY_UNIT = {
+    "gate-evaluate": "Run verification checks to answer the gate question, then persist the verdict with `gsd_save_gate_result`.",
 };
 /**
  * Render the Context Mode instruction lane for a unit type. Unknown unit
@@ -112,7 +126,9 @@ export function composeContextModeInstructions(unitType, opts) {
     if (!manifest || manifest.contextMode === "none")
         return "";
     const lane = CONTEXT_MODE_LANE_LABELS[manifest.contextMode];
-    const guidance = CONTEXT_MODE_GUIDANCE_BY_UNIT[unitType] ?? CONTEXT_MODE_GUIDANCE_BY_LANE[manifest.contextMode];
+    const guidance = (opts.renderMode === "nested" ? CONTEXT_MODE_NESTED_GUIDANCE_BY_UNIT[unitType] : undefined)
+        ?? CONTEXT_MODE_GUIDANCE_BY_UNIT[unitType]
+        ?? CONTEXT_MODE_GUIDANCE_BY_LANE[manifest.contextMode];
     if (opts.renderMode === "nested") {
         return `Context Mode (${lane} lane): ${guidance}`;
     }

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -178,9 +178,10 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // Validation may need to run shell verification commands and apply source
-        // fixes before milestone closeout can proceed.
-        tools: TOOLS_ALL,
+        // Validation must persist its durable output through gsd_validate_milestone;
+        // generic write/bash tools can create filesystem artifacts that bypass DB
+        // state and trigger destructive recovery loops.
+        tools: { mode: "workflow-only", allowedSubagents: ["reviewer", "security", "tester"] },
         artifacts: {
             inline: ["roadmap", "requirements", "templates"],
             excerpt: ["slice-summary", "slice-assessment"],
@@ -531,7 +532,7 @@ export function compileSubagentPermissionContract(policy) {
     if (policy.mode === "all") {
         return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
     }
-    if ((policy.mode === "planning-dispatch" || policy.mode === "verification") &&
+    if ((policy.mode === "planning-dispatch" || policy.mode === "verification" || policy.mode === "workflow-only") &&
         Array.isArray(policy.allowedSubagents)) {
         return {
             allowed: policy.allowedSubagents.length > 0,

package/dist/resources/extensions/gsd/unit-registry.js

@@ -51,7 +51,13 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_summary_save",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_summary_save"],
         },
     },
@@ -64,10 +70,11 @@ export const UNIT_REGISTRY = {
                 "gsd_milestone_status",
                 "gsd_plan_milestone",
                 "gsd_plan_slice",
+                "gsd_plan_task",
                 "gsd_decision_save",
                 "gsd_requirement_update",
             ],
-            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
+            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"],
         },
     },
     "discuss-milestone": {
@@ -107,7 +114,15 @@ export const UNIT_REGISTRY = {
         scopeClass: "section-close",
         phaseChain: ["validation", "planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_validate_milestone",
+                "gsd_reassess_roadmap",
+                "subagent",
+            ],
             requiredWorkflowTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
         },
     },
@@ -118,6 +133,9 @@ export const UNIT_REGISTRY = {
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
                 "gsd_requirement_update",
                 "gsd_summary_save",
                 "gsd_complete_milestone",
@@ -136,7 +154,14 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_summary_save",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_summary_save"],
         },
     },
@@ -145,8 +170,17 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_plan_slice", "gsd_reassess_roadmap", "gsd_decision_save"],
-            requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_plan_slice",
+                "gsd_plan_task",
+                "gsd_reassess_roadmap",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
+            requiredWorkflowTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"],
         },
     },
     "refine-slice": {
@@ -154,7 +188,14 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_plan_slice", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_plan_slice",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_plan_slice"],
         },
     },
@@ -173,7 +214,10 @@ export const UNIT_REGISTRY = {
         phaseChain: ["completion"],
         toolContract: {
             allowedGsdTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
@@ -184,6 +228,7 @@ export const UNIT_REGISTRY = {
                 "subagent",
             ],
             requiredWorkflowTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
                 "gsd_capture_thought",
                 "gsd_slice_complete",
@@ -255,7 +300,13 @@ export const UNIT_REGISTRY = {
         scopeClass: "execute-task",
         phaseChain: ["execution"],
         toolContract: {
-            allowedGsdTools: ["gsd_task_complete", "gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_summary_save",
+                "gsd_decision_save",
+            ],
             requiredWorkflowTools: ["gsd_task_complete", "gsd_summary_save"],
         },
     },
@@ -342,12 +393,15 @@ export const UNIT_REGISTRY = {
             requiredWorkflowTools: ["ask_user_questions"],
         },
     },
+    // research-project dispatches 4 parallel scout subagents (Task calls); each scout
+    // writes one file under .gsd/research/ directly. The parent coordinator does not
+    // call gsd_summary_save or gsd_decision_save — the scouts own their own output.
     "research-project": {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [],
             requiredWorkflowTools: [],
         },
     },

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -93,6 +93,8 @@ export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, up
     const path = runtimePath(basePath, unitType, unitId);
     return withRecordLock(path, () => {
         const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
+        const sameRun = prev?.startedAt === startedAt;
+        const updatesHarnessAbort = Object.prototype.hasOwnProperty.call(updates, "harnessAbort");
         const next = {
             version: 1,
             unitType,
@@ -109,11 +111,24 @@ export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, up
             recovery: updates.recovery ?? prev?.recovery,
             recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
             lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
+            harnessAbort: updatesHarnessAbort
+                ? updates.harnessAbort
+                : (sameRun ? prev?.harnessAbort : undefined),
         };
         atomicWriteSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
         return next;
     });
 }
+export function recordUnitHarnessAbort(basePath, unitType, unitId, startedAt, abort) {
+    return writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, {
+        harnessAbort: {
+            ...abort,
+            recordedAt: abort.recordedAt ?? Date.now(),
+        },
+        lastProgressAt: Date.now(),
+        lastProgressKind: `harness-abort:${abort.kind}`,
+    });
+}
 export function readUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);
     if (!existsSync(path))
@@ -125,6 +140,12 @@ export function readUnitRuntimeRecord(basePath, unitType, unitId) {
         return null;
     }
 }
+export function readUnitHarnessAbort(basePath, unitType, unitId, startedAt) {
+    const record = readUnitRuntimeRecord(basePath, unitType, unitId);
+    if (!record || record.startedAt !== startedAt)
+        return null;
+    return record.harnessAbort ?? null;
+}
 export function clearUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);
     if (existsSync(path))

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -1,22 +1,38 @@
 // Project/App: gsd-pi
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
-import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, } from "./native-git-bridge.js";
+import { execFileSync } from "node:child_process";
+import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, nativeIsAncestor, } from "./native-git-bridge.js";
 import { autoWorktreeBranch } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { captureRootDirtySnapshot } from "./root-write-leak-guard.js";
 import { isClosedStatus } from "./status-guards.js";
 const BLOCKED_COMMANDS = new Set([
     "auto",
     "next",
-    "parallel",
     "start",
     "workflow",
     "new-milestone",
     "new-project",
     "do",
+    "discuss-phase",
+    "plan-phase",
+    "execute-phase",
+    "spec-phase",
+    "mvp-phase",
+    "ui-phase",
+    "ai-integration-phase",
+    "ultraplan-phase",
+    "validate-phase",
+    "docs-update",
+    "review-backlog",
+    "import",
+    "ingest-docs",
+    "secure-phase",
+    "plan-review-convergence",
+    "autonomous",
+    "resume-work",
     "execute-task",
     "research-milestone",
     "plan-slice",
@@ -26,13 +42,53 @@ const BLOCKED_COMMANDS = new Set([
     "validate-milestone",
     "complete-milestone",
 ]);
+const UNMERGED_SAFE_PARALLEL_SUBCOMMANDS = new Set([
+    "status",
+    "watch",
+]);
 function isRuntimePath(path) {
     return path === ".gsd" || path.startsWith(".gsd/");
 }
+function captureDirtyPathStatusSnapshot(rootPath) {
+    const snapshot = new Map();
+    let status = "";
+    try {
+        status = execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], {
+            cwd: rootPath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch {
+        return snapshot;
+    }
+    for (const line of status.split("\n")) {
+        if (!line.trim())
+            continue;
+        const code = line.slice(0, 2);
+        const path = line.slice(3).replace(/^"|"$/g, "");
+        if (!path || isRuntimePath(path))
+            continue;
+        snapshot.set(path, {
+            path,
+            status: code.trim() || code,
+        });
+    }
+    return snapshot;
+}
 function formatCommandLabel(attemptedCommand) {
     const trimmed = attemptedCommand.trim();
     return trimmed ? `/gsd ${trimmed}` : "/gsd";
 }
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 function resolveIntegrationBranch(base, milestoneId) {
     const prefs = loadEffectiveGSDPreferences(base)?.preferences?.git ?? {};
     const resolution = resolveMilestoneIntegrationBranch(base, milestoneId, prefs);
@@ -57,12 +113,30 @@ export function isUnmergedMilestoneAllowedCommand(trimmed) {
     if (name === "dispatch") {
         return subcommand === "complete" || subcommand === "complete-milestone";
     }
+    if (name === "audit-fix") {
+        return hasFlag(command, "--dry-run");
+    }
+    if (name === "code-review") {
+        return !hasFlag(command, "--fix");
+    }
+    if (name === "docs-update") {
+        return hasFlag(command, "--verify-only");
+    }
+    if (name === "parallel") {
+        return UNMERGED_SAFE_PARALLEL_SUBCOMMANDS.has(subcommand ?? "");
+    }
+    if (name === "phase") {
+        return !isMutatingPhaseCommand(subcommand);
+    }
+    if (name === "progress") {
+        return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+    }
     return !BLOCKED_COMMANDS.has(name);
 }
 export async function findUnmergedCompletedMilestones(base) {
     await ensureDbOpen(base);
     const blockers = [];
-    const dirtyByPath = captureRootDirtySnapshot(base);
+    let dirtyByPath = null;
     for (const milestone of getAllMilestones()) {
         if (!isClosedStatus(milestone.status))
             continue;
@@ -72,19 +146,31 @@ export async function findUnmergedCompletedMilestones(base) {
         const integrationBranch = resolveIntegrationBranch(base, milestone.id);
         if (!integrationBranch || integrationBranch === branch)
             continue;
+        // The milestone is merged when its branch tip is reachable from the
+        // integration branch tip — true for fast-forward, --no-ff, and squash
+        // merges alike. A raw diff is the wrong predicate: a --no-ff merge that
+        // took main's side for some conflicts leaves the branch tip differing from
+        // main, which the diff check would misread as "unmerged" (#825). The diff
+        // below remains the correct fallback only when the branch is NOT yet an
+        // ancestor — i.e. the merge is genuinely still pending.
+        if (nativeIsAncestor(base, branch, integrationBranch))
+            continue;
         const files = nativeDiffNumstat(base, integrationBranch, branch)
             .map((entry) => entry.path)
             .filter((path) => path && !isRuntimePath(path));
         const uniqueFiles = [...new Set(files)].sort();
         if (uniqueFiles.length === 0)
             continue;
+        if (!dirtyByPath)
+            dirtyByPath = captureDirtyPathStatusSnapshot(base);
+        const dirtySnapshot = dirtyByPath;
         blockers.push({
             milestoneId: milestone.id,
             branch,
             integrationBranch,
             files: uniqueFiles,
             dirtyOverlap: uniqueFiles
-                .map((path) => dirtyByPath.get(path))
+                .map((path) => dirtySnapshot.get(path))
                 .filter((entry) => Boolean(entry)),
         });
     }

package/dist/resources/extensions/gsd/validation-block-guard.js

@@ -5,7 +5,7 @@ import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";
-import { deriveState } from "./state.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import { detectWorktreeName } from "./worktree.js";
 const VALIDATION_BLOCK_RE = /milestone validation returned needs-(?:attention|remediation)|validation verdict is needs-(?:attention|remediation)/i;
 const VALIDATION_SAFE_DISPATCH_COMMANDS = new Set([
@@ -21,6 +21,27 @@ const VALIDATION_BLOCKED_COMMANDS = new Set([
     "ship",
     "complete-milestone",
     "do",
+    "discuss-phase",
+    "import",
+    "ingest-docs",
+    "review-backlog",
+    "docs-update",
+    "secure-phase",
+    "plan-phase",
+    "execute-phase",
+    "spec-phase",
+    "mvp-phase",
+    "ui-phase",
+    "ai-integration-phase",
+    "ultraplan-phase",
+    "plan-review-convergence",
+    "autonomous",
+    "resume-work",
+    "discuss-phase",
+    "import",
+    "ingest-docs",
+    "review-backlog",
+    "secure-phase",
 ]);
 const VALIDATION_BLOCKED_PARALLEL_SUBCOMMANDS = new Set([
     "",
@@ -38,6 +59,15 @@ const VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS = new Set([
     "install",
     "uninstall",
 ]);
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 export function isValidationBlockedState(state) {
     if (state.phase !== "blocked")
         return false;
@@ -57,6 +87,21 @@ export function isValidationBlockAllowedCommand(trimmed) {
     if (name === "workflow") {
         return VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS.has(subcommand ?? "");
     }
+    if (name === "audit-fix") {
+        return hasFlag(command, "--dry-run");
+    }
+    if (name === "code-review") {
+        return !hasFlag(command, "--fix");
+    }
+    if (name === "docs-update") {
+        return hasFlag(command, "--verify-only");
+    }
+    if (name === "phase") {
+        return !isMutatingPhaseCommand(subcommand);
+    }
+    if (name === "progress") {
+        return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+    }
     return !VALIDATION_BLOCKED_COMMANDS.has(name);
 }
 export function formatValidationBlockedMessage(state, attemptedCommand = "") {
@@ -71,9 +116,7 @@ export function formatValidationBlockedMessage(state, attemptedCommand = "") {
         ...blockers,
     ].join("\n\n");
 }
-export async function getValidationBlockMessageForBase(base, attemptedCommand = "") {
-    await ensureDbOpen(base);
-    refreshWorkflowDatabaseFromDisk();
+async function deriveValidationBlockState(base) {
     let state = await deriveState(base);
     if (state.activeMilestone &&
         getIsolationMode(base) === "worktree" &&
@@ -84,5 +127,12 @@ export async function getValidationBlockMessageForBase(base, attemptedCommand =
             state = await deriveState(wtPath);
         }
     }
+    return state;
+}
+export async function getValidationBlockMessageForBase(base, attemptedCommand = "") {
+    await ensureDbOpen(base);
+    refreshWorkflowDatabaseFromDisk();
+    invalidateStateCache();
+    const state = await deriveValidationBlockState(base);
     return formatValidationBlockedMessage(state, attemptedCommand);
 }

package/dist/resources/extensions/gsd/verification-gate.js

@@ -201,6 +201,13 @@ export function formatFailureContext(result) {
     }
     return header + body;
 }
+export function formatFailureSignature(result) {
+    return result.checks
+        .filter((check) => check.exitCode !== 0)
+        .map((check) => `${check.command.trim()}#${check.exitCode}`)
+        .sort()
+        .join("\n");
+}
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 /** Characters that indicate shell control syntax when unquoted in a command string. */
 const UNQUOTED_SHELL_CONTROL_CHARS = new Set([";", "<", ">"]);