gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.3118184

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

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -286,6 +286,26 @@ function reconcileDiskToDb(basePath) {
                 depends: s.depends, demo: s.demo,
             });
         }
+        // Reconcile stale *existing* slice rows (#3599): a slice row may exist in
+        // the DB with status "pending" even though disk artifacts (SUMMARY) prove
+        // completion — the same class of desync that task-level reconciliation
+        // (further below) already handles.  Without this, the dependency resolver
+        // builds doneSliceIds from stale DB rows and downstream slices stay blocked
+        // forever with "No slice eligible".
+        for (const dbSlice of dbSlices) {
+            if (isStatusDone(dbSlice.status))
+                continue;
+            const summaryPath = resolveSliceFile(basePath, mid, dbSlice.id, "SUMMARY");
+            if (summaryPath) {
+                try {
+                    updateSliceStatus(mid, dbSlice.id, "complete");
+                    logWarning("reconcile", `slice ${mid}/${dbSlice.id} status reconciled from "${dbSlice.status}" to "complete" (#3599)`, { mid, sid: dbSlice.id });
+                }
+                catch (e) {
+                    logError("reconcile", `failed to update slice ${dbSlice.id}`, { sid: dbSlice.id, error: e.message });
+                }
+            }
+        }
     }
     return allMilestones;
 }
@@ -724,7 +744,14 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
-    const pendingGateCount = getPendingSliceGateCount(activeMilestone.id, activeSlice.id);
+    // ── Quality gate evaluation check ──────────────────────────────────
+    // Pause before execution only when gates owned by the `gate-evaluate`
+    // turn (Q3/Q4) are still pending. Q8 is also `scope:"slice"` but is
+    // owned by `complete-slice`, so it must NOT block the evaluating-gates
+    // phase — otherwise auto-loop stalls forever waiting for a gate that
+    // this turn never evaluates. See gate-registry.ts for the ownership map.
+    // Slices with zero gate rows (pre-feature or simple) skip straight through.
+    const pendingGateCount = getPendingGateCountForTurn(activeMilestone.id, activeSlice.id, "gate-evaluate");
     if (pendingGateCount > 0) {
         return {
             activeMilestone, activeSlice, activeTask: null,

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";
@@ -323,7 +324,9 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
             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(", ")}` }],

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

@@ -138,6 +138,13 @@ export function renderRoadmapProjection(basePath, milestoneId) {
  *   regeneration, they are queried from the DB by renderSummaryProjection.
  */
 export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
+    // If the task already has a fully rendered summary (written by handleCompleteTask's
+    // renderSummaryMarkdown), use it as-is. That content already includes frontmatter,
+    // heading, and all sections. Re-wrapping it inside a second frontmatter/heading
+    // envelope produces double frontmatter and duplicate sections.
+    if (taskRow.full_summary_md && taskRow.full_summary_md.trimStart().startsWith("---")) {
+        return taskRow.full_summary_md;
+    }
     // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
     const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
         ? taskRow.key_files.map(f => `  - ${f}`).join("\n")

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

@@ -468,14 +468,41 @@ export function removeWorktree(basePath, name, opts = {}) {
         }
     }
 }
-/** Paths to skip in all worktree diffs (internal/runtime artifacts). */
-const SKIP_PATHS = [".gsd/worktrees/", ".gsd/runtime/", ".gsd/activity/"];
-const SKIP_EXACT = [".gsd/STATE.md", ".gsd/auto.lock", ".gsd/metrics.json"];
+/**
+ * Paths to skip in all worktree diffs (internal/runtime artifacts).
+ *
+ * NOTE: These arrays must stay synchronized with GSD_RUNTIME_PATTERNS in gitignore.ts.
+ * That file is the canonical source of truth for runtime ignore patterns.
+ * This module uses a split representation (paths/exact/prefixes) for efficient matching.
+ */
+const SKIP_PATHS = [
+    ".gsd/worktrees/",
+    ".gsd/runtime/",
+    ".gsd/activity/",
+    ".gsd/forensics/",
+    ".gsd/parallel/",
+    ".gsd/journal/",
+];
+const SKIP_EXACT = [
+    ".gsd/STATE.md",
+    ".gsd/auto.lock",
+    ".gsd/metrics.json",
+    ".gsd/state-manifest.json",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
+];
+/** File prefixes to skip (for wildcard patterns like completed-units*.json, gsd.db*). */
+const SKIP_PREFIXES = [
+    ".gsd/completed-units",
+    ".gsd/gsd.db",
+];
 function shouldSkipPath(filePath) {
     if (SKIP_PATHS.some(p => filePath.startsWith(p)))
         return true;
     if (SKIP_EXACT.includes(filePath))
         return true;
+    if (SKIP_PREFIXES.some(p => filePath.startsWith(p)))
+        return true;
     return false;
 }
 function parseDiffNameStatus(entries) {

package/dist/resources/extensions/gsd/write-intercept.js

@@ -22,6 +22,9 @@ const BLOCKED_PATTERNS = [
     /(^|[/\\])\.gsd[/\\]STATE\.md$/i,
     // Also match resolved symlink paths under ~/.gsd/projects/ (Pitfall #6)
     /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]STATE\.md$/i,
+    // gsd.db and WAL/SHM files — single-writer WAL connection managed by engine (#3625)
+    /(^|[/\\])\.gsd[/\\]gsd\.db(-wal|-shm)?$/i,
+    /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]gsd\.db(-wal|-shm)?$/i,
 ];
 /**
  * Bash command patterns that target STATE.md.
@@ -38,6 +41,12 @@ const BASH_STATE_PATTERNS = [
     /\bsed\b.*-i.*STATE\.md/i,
     // dd output to STATE.md
     /\bdd\b.*of=\S*STATE\.md/i,
+    // Direct DB access via sqlite3/sql.js/better-sqlite3 targeting gsd.db (#3625)
+    /\b(sqlite3|sql\.js|better-sqlite3|node:sqlite)\b.*gsd\.db/i,
+    /\bgsd\.db\b.*\b(sqlite3|sql\.js|better-sqlite3)\b/i,
+    // Shell writes targeting gsd.db files
+    /[>|]+\s*\S*gsd\.db/i,
+    /\b(cp|mv|dd)\b.*gsd\.db/i,
 ];
 /**
  * Tests whether the given file path matches a blocked authoritative .gsd/ state file.
@@ -75,7 +84,7 @@ function matchesBlockedPattern(path) {
  * Error message returned when an agent attempts to directly write an authoritative .gsd/ state file.
  * Directs the agent to use engine tool calls instead.
  */
-export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md are blocked. Use engine tool calls instead:
+export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
 - To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
 - To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
 - To save a decision: call gsd_save_decision(scope, decision, choice, rationale)

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

@@ -49,16 +49,22 @@ 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
-    // the standard OpenAI-compatible streaming endpoint. Ollama ignores the
-    // Authorization header so the dummy key is harmless.
+    // Use authMode "apiKey" (#3440). Local Ollama ignores the Authorization header,
+    // so the "ollama" fallback is harmless. For cloud endpoints (OLLAMA_HOST pointing
+    // to ollama.com or a remote instance), OLLAMA_API_KEY is picked up here.
     pi.registerProvider("ollama", {
         authMode: "apiKey",
-        apiKey: "ollama",
+        apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
         baseUrl,
         api: "ollama-chat",
         streamSimple: streamOllamaChat,
@@ -102,10 +108,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/ollama/ollama-client.js

@@ -15,11 +15,34 @@ export function getOllamaHost() {
         return host;
     return `http://${host}`;
 }
+/**
+ * Get auth headers for Ollama API requests.
+ * For cloud endpoints (OLLAMA_HOST pointing to ollama.com or remote instances),
+ * OLLAMA_API_KEY is used as a Bearer token. Local Ollama ignores the header.
+ */
+function getAuthHeaders() {
+    const apiKey = process.env.OLLAMA_API_KEY;
+    if (!apiKey)
+        return {};
+    return { Authorization: `Bearer ${apiKey}` };
+}
+/**
+ * Merge auth headers into request options.
+ */
+function withAuth(options = {}) {
+    const authHeaders = getAuthHeaders();
+    if (Object.keys(authHeaders).length === 0)
+        return options;
+    return {
+        ...options,
+        headers: { ...authHeaders, ...(options.headers || {}) },
+    };
+}
 async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        return await fetch(url, { ...options, signal: controller.signal });
+        return await fetch(url, withAuth({ ...options, signal: controller.signal }));
     }
     finally {
         clearTimeout(timeout);
@@ -27,10 +50,16 @@ async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_M
 }
 /**
  * Check if Ollama is running and reachable.
+ * For cloud endpoints (OLLAMA_HOST pointing to ollama.com), uses /api/tags
+ * as the probe since the root endpoint may not be available.
  */
 export async function isRunning() {
     try {
-        const response = await fetchWithTimeout(`${getOllamaHost()}/`, {}, PROBE_TIMEOUT_MS);
+        const host = getOllamaHost();
+        const isCloud = host.includes("ollama.com") || host.includes("cloud");
+        const probeUrl = isCloud ? `${host}/api/tags` : `${host}/`;
+        const timeout = isCloud ? REQUEST_TIMEOUT_MS : PROBE_TIMEOUT_MS;
+        const response = await fetchWithTimeout(probeUrl, isCloud ? { method: "GET" } : {}, timeout);
         return response.ok;
     }
     catch {
@@ -92,12 +121,12 @@ export async function getRunningModels() {
  * Returns when the pull is complete.
  */
 export async function pullModel(name, onProgress, signal) {
-    const response = await fetch(`${getOllamaHost()}/api/pull`, {
+    const response = await fetch(`${getOllamaHost()}/api/pull`, withAuth({
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ name, stream: true }),
         signal,
-    });
+    }));
     if (!response.ok) {
         const text = await response.text();
         throw new Error(`Ollama /api/pull returned ${response.status}: ${text}`);
@@ -114,12 +143,12 @@ export async function pullModel(name, onProgress, signal) {
  * Returns an async generator yielding each NDJSON response chunk.
  */
 export async function* chat(request, signal) {
-    const response = await fetch(`${getOllamaHost()}/api/chat`, {
+    const response = await fetch(`${getOllamaHost()}/api/chat`, withAuth({
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(request),
         signal,
-    });
+    }));
     if (!response.ok) {
         const text = await response.text();
         throw new Error(`Ollama /api/chat returned ${response.status}: ${text}`);

package/dist/resources/extensions/ollama/ollama-discovery.js

@@ -6,14 +6,40 @@
  *
  * Returns models in the format expected by pi.registerProvider().
  */
-import { listModels } from "./ollama-client.js";
+import { listModels, showModel } from "./ollama-client.js";
 import { estimateContextFromParams, formatModelSize, getModelCapabilities, humanizeModelName, } from "./model-capabilities.js";
+/**
+ * Extract context window from /api/show model_info.
+ * Keys follow the pattern "{architecture}.context_length" (e.g. "llama.context_length").
+ */
+function extractContextFromModelInfo(modelInfo) {
+    for (const [key, value] of Object.entries(modelInfo)) {
+        if (key.endsWith(".context_length") && typeof value === "number" && value > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
 const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-function enrichModel(info) {
+async function enrichModel(info, deps) {
     const caps = getModelCapabilities(info.name);
     const parameterSize = info.details?.parameter_size ?? "";
-    // Determine context window: known table > estimate from param size > default
+    // /api/tags doesn't include context length; /api/show does via "{arch}.context_length" in model_info.
+    let showContextWindow;
+    if (caps.contextWindow === undefined) {
+        try {
+            const showData = await deps.showModel(info.name);
+            showContextWindow = extractContextFromModelInfo(showData.model_info);
+        }
+        catch (err) {
+            // non-fatal: fall through to estimate
+            if (process.env.GSD_DEBUG)
+                console.warn(`[ollama] /api/show failed for ${info.name}:`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    // Determine context window: known table > /api/show > estimate from param size > default
     const contextWindow = caps.contextWindow ??
+        showContextWindow ??
         (parameterSize ? estimateContextFromParams(parameterSize) : 8192);
     // Determine max tokens: known table > fraction of context > default
     const maxTokens = caps.maxTokens ?? Math.min(Math.floor(contextWindow / 4), 16384);
@@ -38,11 +64,11 @@ function enrichModel(info) {
 /**
  * Discover all locally available Ollama models with enriched capabilities.
  */
-export async function discoverModels() {
-    const tags = await listModels();
+export async function discoverModels(deps = { listModels, showModel }) {
+    const tags = await deps.listModels();
     if (!tags.models || tags.models.length === 0)
         return [];
-    return tags.models.map(enrichModel);
+    return Promise.all(tags.models.map((m) => enrichModel(m, deps)));
 }
 /**
  * Format a discovered model for display in model list.

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 = {

package/dist/startup-model-validation.d.ts

@@ -13,7 +13,6 @@ interface MinimalModel {
     id: string;
 }
 interface MinimalModelRegistry {
-    getAll(): MinimalModel[];
     getAvailable(): MinimalModel[];
 }
 type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';

package/dist/startup-model-validation.js

@@ -23,10 +23,14 @@ import { getPiDefaultModelAndProvider } from './pi-migration.js';
 export function validateConfiguredModel(modelRegistry, settingsManager) {
     const configuredProvider = settingsManager.getDefaultProvider();
     const configuredModel = settingsManager.getDefaultModel();
-    const allModels = modelRegistry.getAll();
     const availableModels = modelRegistry.getAvailable();
+    // Check against availableModels (configured + auth'd) rather than getAll()
+    // so a stale default pointing at an unconfigured provider triggers the
+    // fallback. Previously a model present in the registry but missing API
+    // key / OAuth would satisfy configuredExists and survive startup, ending
+    // up as ctx.model even though it couldn't actually be used.
     const configuredExists = configuredProvider && configuredModel &&
-        allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
+        availableModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
     if (!configuredModel || !configuredExists) {
         // Model not configured at all, or removed from registry — pick a fallback.
         // Only fires when the model is genuinely unknown (not just temporarily unavailable).

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-cYPZv_bAhZk2ms-Pz6vsY
+NzO79SOz9jHX-VY5-0t2O