gsd-pi 2.70.1 → 2.71.0-dev.246c32d

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

@@ -9,7 +9,8 @@
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -19,6 +20,19 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+/**
+ * Map a complete-slice-owned gate id to the CompleteSliceParams field
+ * whose presence drives `pass` vs. `omitted`. Keep this in lockstep with
+ * the gates declared in gate-registry.ts under ownerTurn "complete-slice".
+ */
+function sliceGateFieldForId(id, params) {
+    switch (id) {
+        case "Q8":
+            return params.operationalReadiness;
+        default:
+            return undefined;
+    }
+}
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -134,6 +148,10 @@ ${reqSurfaced}
 
 ${reqInvalidated}
 
+## Operational Readiness
+
+${params.operationalReadiness?.trim() || "None."}
+
 ## Deviations
 
 ${params.deviations || "None."}
@@ -271,6 +289,39 @@ export async function handleCompleteSlice(params, basePath) {
     }
     // Store rendered markdown in DB for D004 recovery
     setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
+    // ── Close gates owned by complete-slice (Q8) ───────────────────────────
+    // Each owned gate maps to a specific summary section via the registry.
+    // If the caller populated the corresponding field, record `pass`; if the
+    // field is empty, record `omitted`. Without this loop, Q8 would stay
+    // pending forever and block future state derivation (see gate-registry).
+    try {
+        const pendingGates = getPendingGatesForTurn(params.milestoneId, params.sliceId, "complete-slice");
+        if (pendingGates.length > 0) {
+            const ownedDefs = new Map(getGatesForTurn("complete-slice").map((g) => [g.id, g]));
+            for (const row of pendingGates) {
+                const def = ownedDefs.get(row.gate_id);
+                if (!def)
+                    continue;
+                // Map gate id → param field it maps to. Keep the map local so
+                // adding a new complete-slice gate is a single place change.
+                const field = sliceGateFieldForId(def.id, params);
+                const hasContent = typeof field === "string" && field.trim().length > 0;
+                saveGateResult({
+                    milestoneId: params.milestoneId,
+                    sliceId: params.sliceId,
+                    gateId: def.id,
+                    verdict: hasContent ? "pass" : "omitted",
+                    rationale: hasContent
+                        ? `${def.promptSection} section populated in slice summary`
+                        : `${def.promptSection} section left empty — recorded as omitted`,
+                    findings: hasContent ? field.trim() : "",
+                });
+            }
+        }
+    }
+    catch (gateErr) {
+        logWarning("tool", `complete-slice gate close warning for ${params.milestoneId}/${params.sliceId}: ${gateErr.message}`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -9,7 +9,8 @@
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -19,6 +20,23 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+/**
+ * Map an execute-task-owned gate id to the CompleteTaskParams field whose
+ * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
+ * declared in gate-registry.ts under ownerTurn "execute-task".
+ */
+function taskGateFieldForId(id, params) {
+    switch (id) {
+        case "Q5":
+            return params.failureModes;
+        case "Q6":
+            return params.loadProfile;
+        case "Q7":
+            return params.negativeTests;
+        default:
+            return undefined;
+    }
+}
 /**
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
@@ -189,6 +207,38 @@ export async function handleCompleteTask(params, basePath) {
     }
     // Store rendered markdown in DB for D004 recovery
     setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
+    // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
+    // Each gate id maps to a specific params field via taskGateFieldForId.
+    // When the model populates the field, record `pass`; when it's empty,
+    // record `omitted`. Task-scoped rows are filtered by taskId so a single
+    // task's completion doesn't touch sibling tasks' gate rows.
+    try {
+        const pendingGates = getPendingGatesForTurn(params.milestoneId, params.sliceId, "execute-task", params.taskId);
+        if (pendingGates.length > 0) {
+            const ownedDefs = new Map(getGatesForTurn("execute-task").map((g) => [g.id, g]));
+            for (const row of pendingGates) {
+                const def = ownedDefs.get(row.gate_id);
+                if (!def)
+                    continue;
+                const field = taskGateFieldForId(def.id, params);
+                const hasContent = typeof field === "string" && field.trim().length > 0;
+                saveGateResult({
+                    milestoneId: params.milestoneId,
+                    sliceId: params.sliceId,
+                    taskId: params.taskId,
+                    gateId: def.id,
+                    verdict: hasContent ? "pass" : "omitted",
+                    rationale: hasContent
+                        ? `${def.promptSection} section populated in task summary`
+                        : `${def.promptSection} section left empty — recorded as omitted`,
+                    findings: hasContent ? field.trim() : "",
+                });
+            }
+        }
+    }
+    catch (gateErr) {
+        logWarning("tool", `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${gateErr.message}`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

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

@@ -2,6 +2,7 @@ import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
 import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, saveGateResult, } from "../gsd-db.js";
+import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
@@ -23,12 +24,14 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
             details: { operation: "save_summary", error: "db_unavailable" },
+            isError: true,
         };
     }
     if (!isSupportedSummaryArtifactType(params.artifact_type)) {
         return {
             content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
             details: { operation: "save_summary", error: "invalid_artifact_type" },
+            isError: true,
         };
     }
     const contextGuard = shouldBlockContextArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
@@ -36,6 +39,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
             details: { operation: "save_summary", error: "context_write_blocked" },
+            isError: true,
         };
     }
     try {
@@ -68,6 +72,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
             details: { operation: "save_summary", error: msg },
+            isError: true,
         };
     }
 }
@@ -77,6 +82,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
             details: { operation: "complete_task", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -87,6 +93,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing task: ${result.error}` }],
                 details: { operation: "complete_task", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -106,6 +113,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing task: ${msg}` }],
             details: { operation: "complete_task", error: msg },
+            isError: true,
         };
     }
 }
@@ -115,6 +123,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
             details: { operation: "complete_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -167,6 +176,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
                 details: { operation: "complete_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -186,6 +196,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing slice: ${msg}` }],
             details: { operation: "complete_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -195,6 +206,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
             details: { operation: "complete_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -204,6 +216,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
                 details: { operation: "complete_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -221,6 +234,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
             details: { operation: "complete_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -230,6 +244,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
             details: { operation: "validate_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -238,6 +253,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
                 details: { operation: "validate_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -256,6 +272,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
             details: { operation: "validate_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -265,6 +282,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
             details: { operation: "reassess_roadmap", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -273,6 +291,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
                 details: { operation: "reassess_roadmap", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -292,6 +311,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
             details: { operation: "reassess_roadmap", error: msg },
+            isError: true,
         };
     }
 }
@@ -301,13 +321,17 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available." }],
             details: { operation: "save_gate_result", error: "db_unavailable" },
+            isError: true,
         };
     }
-    const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
+    // Source of truth: gate-registry.ts. Every declared GateId is accepted,
+    // so adding a new gate in one place automatically flows through here.
+    const validGates = Object.keys(GATE_REGISTRY);
     if (!validGates.includes(params.gateId)) {
         return {
             content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_gate_id" },
+            isError: true,
         };
     }
     const validVerdicts = ["pass", "flag", "omitted"];
@@ -315,6 +339,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_verdict" },
+            isError: true,
         };
     }
     try {
@@ -339,6 +364,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
             details: { operation: "save_gate_result", error: msg },
+            isError: true,
         };
     }
 }
@@ -348,6 +374,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
             details: { operation: "plan_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -356,6 +383,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
                 details: { operation: "plan_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -373,6 +401,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
             details: { operation: "plan_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -382,6 +411,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
             details: { operation: "plan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -390,6 +420,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
                 details: { operation: "plan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -409,6 +440,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning slice: ${msg}` }],
             details: { operation: "plan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -418,6 +450,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
             details: { operation: "replan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -426,6 +459,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
                 details: { operation: "replan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -445,6 +479,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
             details: { operation: "replan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -455,6 +490,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available." }],
                 details: { operation: "milestone_status", error: "db_unavailable" },
+                isError: true,
             };
         }
         const adapter = _getAdapter();
@@ -503,6 +539,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
             details: { operation: "milestone_status", error: msg },
+            isError: true,
         };
     }
 }

package/dist/resources/extensions/gsd/workflow-events.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
+import { withFileLockSync } from "./file-lock.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── Session ID ───────────────────────────────────────────────────────────
 /**
@@ -88,17 +89,28 @@ export function findForkPoint(logA, logB) {
 export function compactMilestoneEvents(basePath, milestoneId) {
     const logPath = join(basePath, ".gsd", "event-log.jsonl");
     const archivePath = join(basePath, ".gsd", `event-log-${milestoneId}.jsonl.archived`);
-    const allEvents = readEvents(logPath);
-    const toArchive = allEvents.filter((e) => e.params.milestoneId === milestoneId);
-    const remaining = allEvents.filter((e) => e.params.milestoneId !== milestoneId);
-    if (toArchive.length === 0) {
-        return { archived: 0 };
-    }
-    // Write archived events to .jsonl.archived file (crash-safe)
-    atomicWriteSync(archivePath, toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n");
-    // Truncate active log to remaining events only
-    atomicWriteSync(logPath, remaining.length > 0
-        ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
-        : "");
-    return { archived: toArchive.length };
+    return withFileLockSync(logPath, () => {
+        const allEvents = readEvents(logPath);
+        // Single-pass partition to halve the work (per reviewer agent)
+        const toArchive = [];
+        const remaining = [];
+        for (const e of allEvents) {
+            if (e.params.milestoneId === milestoneId) {
+                toArchive.push(e);
+            }
+            else {
+                remaining.push(e);
+            }
+        }
+        if (toArchive.length === 0) {
+            return { archived: 0 };
+        }
+        // Write archived events to .jsonl.archived file (crash-safe)
+        atomicWriteSync(archivePath, toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n");
+        // Truncate active log to remaining events only
+        atomicWriteSync(logPath, remaining.length > 0
+            ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
+            : "");
+        return { archived: toArchive.length };
+    });
 }

package/dist/resources/extensions/gsd/workflow-mcp-auto-prep.js

@@ -0,0 +1,56 @@
+import { ensureProjectWorkflowMcpConfig, } from "./mcp-project-config.js";
+import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
+function getAuthModeSafe(ctx, provider) {
+    if (!provider)
+        return undefined;
+    const getAuthMode = ctx.modelRegistry?.getProviderAuthMode;
+    if (typeof getAuthMode !== "function")
+        return undefined;
+    try {
+        return getAuthMode(provider);
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasClaudeCodeProvider(ctx) {
+    return getAuthModeSafe(ctx, "claude-code") === "externalCli";
+}
+function isClaudeCodeProviderReady(ctx) {
+    const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
+    if (typeof readyCheck !== "function")
+        return false;
+    try {
+        return readyCheck("claude-code");
+    }
+    catch {
+        return false;
+    }
+}
+export function shouldAutoPrepareWorkflowMcp(ctx) {
+    const provider = ctx.model?.provider;
+    const baseUrl = ctx.model?.baseUrl;
+    const authMode = getAuthModeSafe(ctx, provider);
+    if (usesWorkflowMcpTransport(authMode, baseUrl))
+        return true;
+    if (provider === "claude-code")
+        return true;
+    if (hasClaudeCodeProvider(ctx))
+        return true;
+    return isClaudeCodeProviderReady(ctx);
+}
+export function prepareWorkflowMcpForProject(ctx, projectRoot) {
+    if (!shouldAutoPrepareWorkflowMcp(ctx))
+        return null;
+    try {
+        const result = ensureProjectWorkflowMcpConfig(projectRoot);
+        if (result.status !== "unchanged") {
+            ctx.ui?.notify?.(`Claude Code MCP prepared at ${result.configPath}`, "info");
+        }
+        return result;
+    }
+    catch (err) {
+        ctx.ui?.notify?.(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root.`, "warning");
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -310,7 +310,7 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     const unitLabel = options.unitType ? ` for ${options.unitType}` : "";
     const providerLabel = `"${provider}"`;
     if (!launch) {
-        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
+        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
     const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)

package/dist/resources/extensions/ollama/index.js

@@ -49,8 +49,15 @@ async function probeAndRegister(pi) {
         return false;
     }
     const models = await discoverModels();
-    if (models.length === 0)
-        return true; // Running but no models pulled
+    if (models.length === 0) {
+        // No local models means there's nothing usable to register in GSD.
+        // Keep the footer/status clean instead of advertising Ollama availability.
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        return false;
+    }
     const baseUrl = client.getOllamaHost();
     // Use authMode "apiKey" with a dummy key (#3440).
     // authMode "none" requires a custom streamSimple handler, but Ollama uses
@@ -102,10 +109,11 @@ export default function ollama(pi) {
         else {
             probeAndRegister(pi)
                 .then((found) => {
-                if (found)
-                    ctx.ui.setStatus("ollama", "Ollama");
+                ctx.ui.setStatus("ollama", found ? "Ollama" : undefined);
             })
-                .catch(() => { });
+                .catch(() => {
+                ctx.ui.setStatus("ollama", undefined);
+            });
         }
     });
     pi.on("session_shutdown", async () => {

package/dist/resources/extensions/shared/gsd-phase-state.js

@@ -0,0 +1,35 @@
+/**
+ * GSD Phase State — cross-extension coordination
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ *
+ * Lightweight module-level state that GSD auto-mode writes to and the
+ * subagent tool reads from. Both extensions run in the same process so
+ * a module variable is sufficient — no file I/O needed.
+ */
+let _active = false;
+let _currentPhase = null;
+/** Mark GSD auto-mode as active. */
+export function activateGSD() {
+    _active = true;
+}
+/** Mark GSD auto-mode as inactive and clear the current phase. */
+export function deactivateGSD() {
+    _active = false;
+    _currentPhase = null;
+}
+/** Set the currently dispatched GSD phase (e.g. "plan-milestone"). */
+export function setCurrentPhase(phase) {
+    _currentPhase = phase;
+}
+/** Clear the current phase (unit completed or aborted). */
+export function clearCurrentPhase() {
+    _currentPhase = null;
+}
+/** Returns true if GSD auto-mode is currently active. */
+export function isGSDActive() {
+    return _active;
+}
+/** Returns the current GSD phase, or null if none is active. */
+export function getCurrentPhase() {
+    return _active ? _currentPhase : null;
+}

package/dist/resources/extensions/subagent/agents.js

@@ -5,6 +5,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 const PROJECT_AGENT_DIR_CANDIDATES = [".gsd", ".pi"];
+export function parseConflictsWith(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const conflicts = value.split(",").map((s) => s.trim()).filter(Boolean);
+    return conflicts.length > 0 ? conflicts : undefined;
+}
 function parseAgentTools(value) {
     if (typeof value === "string") {
         const tools = value
@@ -52,11 +58,13 @@ function loadAgentsFromDir(dir, source) {
             continue;
         }
         const tools = parseAgentTools(frontmatter.tools);
+        const conflictsWith = parseConflictsWith(frontmatter.conflicts_with);
         agents.push({
             name: frontmatter.name,
             description: frontmatter.description,
             tools: tools && tools.length > 0 ? tools : undefined,
             model: frontmatter.model,
+            conflictsWith,
             systemPrompt: body,
             source,
             filePath,

package/dist/resources/extensions/subagent/index.js

@@ -21,6 +21,7 @@ import { getMarkdownTheme } from "@gsd/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { formatTokenCount } from "../shared/mod.js";
+import { getCurrentPhase } from "../shared/gsd-phase-state.js";
 import { discoverAgents } from "./agents.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
@@ -268,6 +269,22 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             step,
         };
     }
+    // GSD phase guard: block agents that conflict with the active GSD phase
+    if (agent.conflictsWith && agent.conflictsWith.length > 0) {
+        const activePhase = getCurrentPhase();
+        if (activePhase && agent.conflictsWith.includes(activePhase)) {
+            return {
+                agent: agentName,
+                agentSource: agent.source,
+                task,
+                exitCode: 1,
+                messages: [],
+                stderr: `Agent "${agentName}" is blocked: it conflicts with the active GSD phase "${activePhase}". Use the built-in GSD workflow instead.`,
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+                step,
+            };
+        }
+    }
     let tmpPromptDir = null;
     let tmpPromptPath = null;
     const currentResult = {