gsd-pi 2.82.0-dev.725028083 → 2.82.0-dev.9d5798940

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -19,6 +19,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
  * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
@@ -34,7 +35,7 @@ function assertNotAutoActive(action) {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
     assertNotAutoActive("park milestone");
@@ -42,9 +43,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
     if (!mDir || !existsSync(mDir))
         return false;
     // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (summaryFile)
+    const dbAvailable = isDbAvailable();
+    const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+    if (milestone && isClosedStatus(milestone.status))
         return false;
+    if (!dbAvailable) {
+        const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+        if (summaryFile)
+            return false;
+    }
     const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
     if (existsSync(parkedPath))
         return false; // already parked
@@ -61,7 +68,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
     // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-    if (isDbAvailable()) {
+    if (dbAvailable) {
         try {
             updateMilestoneStatus(milestoneId, "parked");
         }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -303,15 +303,20 @@ export function nativeDiffNameStatus(basePath, fromRef, toRef, pathspec, useMerg
 }
 /**
  * Get numstat diff between two refs.
+ * useMergeBase: if true, uses three-dot semantics.
  * Native: libgit2 patch line stats.
  * Fallback: `git diff --numstat`.
  */
-export function nativeDiffNumstat(basePath, fromRef, toRef) {
+export function nativeDiffNumstat(basePath, fromRef, toRef, useMergeBase) {
     const native = loadNative();
-    if (native) {
+    if (native && !useMergeBase) {
         return native.gitDiffNumstat(basePath, fromRef, toRef);
     }
-    const result = gitExec(basePath, ["diff", "--numstat", fromRef, toRef], true);
+    const refspec = useMergeBase ? `${fromRef}...${toRef}` : undefined;
+    const args = refspec
+        ? ["diff", "--numstat", refspec]
+        : ["diff", "--numstat", fromRef, toRef];
+    const result = gitExec(basePath, args, true);
     if (!result)
         return [];
     return result.split("\n").filter(Boolean).map(line => {

package/dist/resources/extensions/gsd/state-reconciliation/drift/merge-state.js

@@ -10,6 +10,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { getErrorMessage } from "../../error-utils.js";
 import { nativeAddPaths, nativeCheckoutTheirs, nativeCommit, nativeConflictFiles, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "../../native-git-bridge.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 const SILENT_NOTIFY = () => { };
 function resolveGitDir(basePath) {
     try {
@@ -23,7 +24,11 @@ function resolveGitDir(basePath) {
         }
     }
     catch (err) {
-        logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+        const message = getErrorMessage(err);
+        logWarning("recovery", `gitdir resolution failed: ${message}`);
+        if (isGsdWorktreePath(basePath)) {
+            throw new Error(`Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`);
+        }
     }
     return join(basePath, ".git");
 }

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

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -127,6 +127,7 @@ export async function handlePlanSlice(rawParams, basePath) {
             if (isDeferredStatus(parentSlice.status)) {
                 updateSliceStatus(params.milestoneId, params.sliceId, "pending");
             }
+            setSliceSketchFlag(params.milestoneId, params.sliceId, false);
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Adapts shared GSD workflow handlers for MCP executor calls.
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
@@ -12,6 +14,9 @@ import { handleCompleteSlice } from "./complete-slice.js";
 import { handlePlanMilestone } from "./plan-milestone.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import { handleReopenMilestone } from "./reopen-milestone.js";
+import { handleReopenSlice } from "./reopen-slice.js";
+import { handleReopenTask } from "./reopen-task.js";
 import { handleReassessRoadmap } from "./reassess-roadmap.js";
 import { handleValidateMilestone } from "./validate-milestone.js";
 import { logError, logWarning } from "../workflow-logger.js";
@@ -274,6 +279,120 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         };
     }
 }
+export async function executeTaskReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
+            details: { operation: "reopen_task", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenTask(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
+                details: { operation: "reopen_task", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+            details: {
+                operation: "reopen_task",
+                taskId: result.taskId,
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_task tool failed: ${msg}`, { tool: "gsd_task_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening task: ${msg}` }],
+            details: { operation: "reopen_task", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeSliceReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
+            details: { operation: "reopen_slice", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenSlice(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
+                details: { operation: "reopen_slice", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened slice ${result.sliceId} (${result.milestoneId})` }],
+            details: {
+                operation: "reopen_slice",
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_slice tool failed: ${msg}`, { tool: "gsd_slice_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening slice: ${msg}` }],
+            details: { operation: "reopen_slice", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeMilestoneReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
+            details: { operation: "reopen_milestone", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenMilestone(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
+                details: { operation: "reopen_milestone", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened milestone ${result.milestoneId}` }],
+            details: {
+                operation: "reopen_milestone",
+                milestoneId: result.milestoneId,
+                slicesReset: result.slicesReset,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_milestone tool failed: ${msg}`, { tool: "gsd_milestone_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening milestone: ${msg}` }],
+            details: { operation: "reopen_milestone", error: msg },
+            isError: true,
+        };
+    }
+}
 export async function executeSliceComplete(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {

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

@@ -73,6 +73,7 @@ const COMMON_BUDGET_SMALL = 250_000; // ~65K tokens
 // allowed-path set for the docs policy lives in one reviewable place.
 const TOOLS_ALL = { mode: "all" };
 const TOOLS_PLANNING = { mode: "planning" };
+const TOOLS_VERIFICATION = { mode: "verification" };
 // Like TOOLS_PLANNING but permits dispatch to read-only recon/planning
 // specialists. Runtime-enforced by write-gate.ts before the subagent tool runs.
 const TOOLS_PLANNING_DISPATCH_RECON = {
@@ -187,8 +188,8 @@ export const UNIT_MANIFESTS = {
         contextMode: "verification",
         // planning-dispatch: validation is a verification-fan-out unit. It reads
         // the milestone surface and dispatches reviewer/security/tester subagents
-        // to report findings without touching user source. Mirrors
-        // complete-milestone's policy. Write isolation to .gsd/ is preserved.
+        // to report findings without touching user source. Write isolation to
+        // .gsd/ is preserved.
         tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["roadmap", "slice-summary", "slice-uat", "requirements", "decisions", "templates"],
@@ -204,11 +205,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // planning-dispatch: completion is a high-leverage place to fan out to
-        // reviewer / security / tester subagents. They read the diff and report
-        // findings; they do not write user source. Write isolation to .gsd/ is
-        // preserved.
-        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
+        // Milestone closeout must run unrestricted shell verification commands
+        // against the final diff before recording completion.
+        tools: TOOLS_ALL,
         artifacts: {
             // #4780 landed slice-summary as excerpt for this unit; phase 2 of
             // the architecture will read this manifest as the source of truth
@@ -227,7 +226,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: true,
         preferences: "active-only",
         contextMode: "research",
-        tools: TOOLS_PLANNING,
+        // Multi-slice research dispatches use the research-slice unit contract to
+        // fan out scout subagents that write .gsd research artifacts.
+        tools: TOOLS_PLANNING_DISPATCH_RECON,
         artifacts: {
             inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
             excerpt: [],
@@ -365,7 +366,7 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        tools: TOOLS_PLANNING,
+        tools: TOOLS_VERIFICATION,
         artifacts: {
             // Phase 3 migration (#4782): manifest matches today's actual
             // buildRunUatPrompt inlining. Prior phase-1 entry listed
@@ -384,7 +385,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        tools: TOOLS_PLANNING,
+        // Gate evaluation fans out tester-style subagents, which read the slice
+        // plan and report via the DB-backed gate-result tool.
+        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries"],
             excerpt: [],
@@ -509,3 +512,22 @@ export const UNIT_MANIFESTS = {
 export function resolveManifest(unitType) {
     return UNIT_MANIFESTS[unitType] ?? null;
 }
+export function compileSubagentPermissionContract(policy) {
+    if (!policy) {
+        return { allowed: false, allowedSubagents: [], toolsMode: "unknown" };
+    }
+    if (policy.mode === "all") {
+        return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
+    }
+    if (policy.mode === "planning-dispatch") {
+        return {
+            allowed: true,
+            allowedSubagents: [...policy.allowedSubagents],
+            toolsMode: policy.mode,
+        };
+    }
+    return { allowed: false, allowedSubagents: [], toolsMode: policy.mode };
+}
+export function resolveSubagentPermissionContract(unitType) {
+    return compileSubagentPermissionContract(resolveManifest(unitType)?.tools);
+}

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

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Host-owned verification verdict policy for auto-mode units.
+export function decideVerificationVerdict(unitType, result) {
+    if (unitType === "execute-task" && result.discoverySource === "none" && result.checks.length === 0) {
+        return {
+            passed: false,
+            reason: "no-host-checks",
+            retryable: false,
+            failureContext: "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+        };
+    }
+    if (!result.passed) {
+        return {
+            passed: false,
+            reason: "checks-failed",
+            retryable: true,
+            failureContext: "",
+        };
+    }
+    return {
+        passed: true,
+        reason: "passed",
+        retryable: false,
+        failureContext: "",
+    };
+}

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

@@ -48,6 +48,11 @@ import { nativeCheckoutBranch } from "./native-git-bridge.js";
 // is the only Module that calls them, and they live alongside the Module's
 // other primitives in `auto-worktree.ts`.
 import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+const recentWorktreeMergeFailures = new Map();
+const MERGE_FAILURE_DEDUPE_MS = 60_000;
+export function resetRecentWorktreeMergeFailuresForTest() {
+    recentWorktreeMergeFailures.clear();
+}
 /**
  * Internal sentinel — thrown by `_mergeBranchMode` when it has already
  * emitted a user-visible error. The outer `mergeAndExit` catches the type
@@ -477,6 +482,28 @@ function rebuildGitService(s, deps) {
     // GitService cast.
     s.gitService = deps.gitServiceFactory(s.basePath);
 }
+function emitWorktreeMergeFailedOnce(basePath, milestoneId, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorCategory = err instanceof Error ? err.name : "Error";
+    const now = Date.now();
+    const key = `${basePath}\0${milestoneId}\0${errorCategory}`;
+    const previous = recentWorktreeMergeFailures.get(key);
+    if (previous && now - previous < MERGE_FAILURE_DEDUPE_MS)
+        return;
+    for (const [candidate, ts] of recentWorktreeMergeFailures) {
+        if (now - ts >= MERGE_FAILURE_DEDUPE_MS) {
+            recentWorktreeMergeFailures.delete(candidate);
+        }
+    }
+    emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: randomUUID(),
+        seq: 0,
+        eventType: "worktree-merge-failed",
+        data: { milestoneId, error: msg },
+    });
+    recentWorktreeMergeFailures.set(key, now);
+}
 // ─── Session-less merge entry (ADR-016 phase 2 / A1) ─────────────────────
 /**
  * Worktree-mode merge body. Session-less — operates on a `MergeContext`.
@@ -590,13 +617,7 @@ function _mergeWorktreeModeImpl(deps, mctx) {
             error: msg,
             fallback: "chdir-to-project-root",
         });
-        emitJournalEvent(originalBasePath || worktreeBasePath, {
-            ts: new Date().toISOString(),
-            flowId: randomUUID(),
-            seq: 0,
-            eventType: "worktree-merge-failed",
-            data: { milestoneId, error: msg },
-        });
+        emitWorktreeMergeFailedOnce(originalBasePath || worktreeBasePath, milestoneId, err);
         // Surface a clear, actionable error. Worktree and milestone branch
         // are intentionally preserved — nothing has been deleted. User can
         // retry /gsd dispatch complete-milestone or merge manually once the
@@ -1198,17 +1219,36 @@ export class WorktreeLifecycle {
         }
     }
     /**
-     * Restore `s.basePath` to `s.originalBasePath` and rebuild `s.gitService`.
-     * No-op when `originalBasePath` is empty (fresh sessions).
+     * Restore `s.basePath` to `s.originalBasePath`, chdir process cwd, and
+     * rebuild `s.gitService`. No-op when `originalBasePath` is empty (fresh
+     * sessions).
      *
      * Used by error/cleanup paths that need the session to behave as if the
      * worktree was never entered. Does NOT teardown the worktree directory —
      * callers that need teardown go through `exitMilestone({ merge: false })`.
+     *
+     * ADR-016 phase 3 (#5693): chdir lives inside the verb so callers do not
+     * pair `restoreToProjectRoot()` with a redundant `process.chdir`. The
+     * chdir runs BEFORE the throwable work (`rebuildGitService`, cache
+     * invalidation) so that cleanup-path cwd is restored even if the
+     * downstream rebuild throws. The chdir itself is best-effort; failure is
+     * logged via debugLog and swallowed.
      */
     restoreToProjectRoot() {
         if (!this.s.originalBasePath)
             return;
         this.s.basePath = this.s.originalBasePath;
+        try {
+            process.chdir(this.s.basePath);
+        }
+        catch (err) {
+            debugLog("WorktreeLifecycle", {
+                action: "restoreToProjectRoot",
+                result: "chdir-failed",
+                basePath: this.s.basePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
         rebuildGitService(this.s, this.deps);
         invalidateAllCaches();
     }