gsd-pi 2.71.0 → 2.72.0-dev.3118184

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -21,7 +21,10 @@ import {
   getMilestone,
   updateSliceStatus,
   setSliceSummaryMd,
+  saveGateResult,
+  getPendingGatesForTurn,
 } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -39,6 +42,23 @@ export interface CompleteSliceResult {
   uatPath: string;
 }
 
+/**
+ * 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: string,
+  params: CompleteSliceParams,
+): string | undefined {
+  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.
@@ -169,6 +189,10 @@ ${reqSurfaced}
 
 ${reqInvalidated}
 
+## Operational Readiness
+
+${params.operationalReadiness?.trim() || "None."}
+
 ## Deviations
 
 ${params.deviations || "None."}
@@ -330,6 +354,45 @@ export async function handleCompleteSlice(
   // 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] as const));
+      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 as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-slice gate close warning for ${params.milestoneId}/${params.sliceId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -24,7 +24,10 @@ import {
   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";
@@ -44,6 +47,27 @@ export interface CompleteTaskResult {
 
 import type { TaskRow } from "../gsd-db.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: string,
+  params: CompleteTaskParams,
+): string | undefined {
+  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).
@@ -236,6 +260,45 @@ export async function handleCompleteTask(
   // 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] as const));
+      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 as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -8,6 +8,7 @@ import {
   _getAdapter,
   saveGateResult,
 } from "../gsd-db.js";
+import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -427,7 +428,9 @@ export async function executeSaveGateResult(
       };
   }
 
-  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/src/resources/extensions/gsd/types.ts

@@ -536,6 +536,24 @@ export interface CompleteTaskParams {
     verdict: string;
     durationMs: number;
   }>;
+  /**
+   * Q5 failure-modes section content (what breaks when dependencies fail).
+   * Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  failureModes?: string;
+  /**
+   * Q6 load-profile section content (10x breakpoint + protection).
+   * Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  loadProfile?: string;
+  /**
+   * Q7 negative-tests section content (malformed inputs, error paths,
+   * boundaries). Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  negativeTests?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -584,6 +602,14 @@ export interface CompleteSliceParams {
   affects?: string[];
   /** @optional — defaults to [] when omitted */
   drillDownPaths?: string[];
+  /**
+   * Q8 operational readiness section content (health signal, failure signal,
+   * recovery, monitoring gaps). When populated, the complete-slice handler
+   * records Q8 as `pass`; when omitted or empty, Q8 is recorded as `omitted`.
+   * See gate-registry.ts.
+   * @optional
+   */
+  operationalReadiness?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -180,6 +180,14 @@ export function renderSummaryContent(
   milestoneId: string,
   evidence?: Array<{ command: string; exitCode?: number; exit_code?: number; verdict: string; durationMs?: number; duration_ms?: number }>,
 ): string {
+  // 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/src/resources/extensions/gsd/worktree-manager.ts

@@ -548,13 +548,39 @@ export function removeWorktree(
   }
 }
 
-/** 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: string): boolean {
   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;
 }
 

package/src/resources/extensions/gsd/write-intercept.ts

@@ -24,6 +24,9 @@ const BLOCKED_PATTERNS: RegExp[] = [
   /(^|[/\\])\.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,
 ];
 
 /**
@@ -41,6 +44,12 @@ const BASH_STATE_PATTERNS: RegExp[] = [
   /\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,
 ];
 
 /**
@@ -81,7 +90,7 @@ function matchesBlockedPattern(path: string): boolean {
  * 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/src/resources/extensions/ollama/index.ts

@@ -57,17 +57,24 @@ async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
 	}
 
 	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,
@@ -115,9 +122,11 @@ export default function ollama(pi: ExtensionAPI) {
 		} 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);
+				});
 		}
 	});
 

package/src/resources/extensions/ollama/ollama-client.ts

@@ -34,11 +34,34 @@ export function getOllamaHost(): string {
 	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(): Record<string, string> {
+	const apiKey = process.env.OLLAMA_API_KEY;
+	if (!apiKey) return {};
+	return { Authorization: `Bearer ${apiKey}` };
+}
+
+/**
+ * Merge auth headers into request options.
+ */
+function withAuth(options: RequestInit = {}): RequestInit {
+	const authHeaders = getAuthHeaders();
+	if (Object.keys(authHeaders).length === 0) return options;
+	return {
+		...options,
+		headers: { ...authHeaders, ...(options.headers as Record<string, string> || {}) },
+	};
+}
+
 async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = REQUEST_TIMEOUT_MS): Promise<Response> {
 	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);
 	}
@@ -46,10 +69,16 @@ async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutM
 
 /**
  * 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(): Promise<boolean> {
 	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 {
 		return false;
@@ -117,12 +146,12 @@ export async function pullModel(
 	onProgress?: (progress: OllamaPullProgress) => void,
 	signal?: AbortSignal,
 ): Promise<void> {
-	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();
@@ -146,12 +175,12 @@ export async function* chat(
 	request: OllamaChatRequest,
 	signal?: AbortSignal,
 ): AsyncGenerator<OllamaChatResponse> {
-	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();

package/src/resources/extensions/ollama/ollama-discovery.ts

@@ -8,7 +8,7 @@
  * 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,
@@ -17,6 +17,24 @@ import {
 } from "./model-capabilities.js";
 import type { OllamaChatOptions, OllamaModelInfo } from "./types.js";
 
+/**
+ * Extract context window from /api/show model_info.
+ * Keys follow the pattern "{architecture}.context_length" (e.g. "llama.context_length").
+ */
+function extractContextFromModelInfo(modelInfo: Record<string, unknown>): number | undefined {
+	for (const [key, value] of Object.entries(modelInfo)) {
+		if (key.endsWith(".context_length") && typeof value === "number" && value > 0) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+type ClientDeps = {
+	listModels: typeof listModels;
+	showModel: typeof showModel;
+};
+
 export interface DiscoveredOllamaModel {
 	id: string;
 	name: string;
@@ -35,13 +53,26 @@ export interface DiscoveredOllamaModel {
 
 const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 
-function enrichModel(info: OllamaModelInfo): DiscoveredOllamaModel {
+async function enrichModel(info: OllamaModelInfo, deps: ClientDeps): Promise<DiscoveredOllamaModel> {
 	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: number | undefined;
+	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
@@ -73,11 +104,11 @@ function enrichModel(info: OllamaModelInfo): DiscoveredOllamaModel {
 /**
  * Discover all locally available Ollama models with enriched capabilities.
  */
-export async function discoverModels(): Promise<DiscoveredOllamaModel[]> {
-	const tags = await listModels();
+export async function discoverModels(deps: ClientDeps = { listModels, showModel }): Promise<DiscoveredOllamaModel[]> {
+	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)));
 }
 
 /**

package/src/resources/extensions/ollama/ollama-status-indicator.test.ts

@@ -0,0 +1,28 @@
+/**
+ * Regression test: don't show an Ollama footer status unless Ollama is
+ * actually usable (running with at least one discovered model).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const src = readFileSync(join(__dirname, "index.ts"), "utf-8");
+
+test("probeAndRegister returns false when no Ollama models are discovered", () => {
+	assert.match(
+		src,
+		/if \(models\.length === 0\)[\s\S]*return false;/,
+		"running-without-models should not be treated as available",
+	);
+});
+
+test("interactive session clears ollama footer status when unavailable", () => {
+	assert.match(
+		src,
+		/ctx\.ui\.setStatus\("ollama", found \? "Ollama" : undefined\)/,
+		"status should be cleared when probeAndRegister reports unavailable",
+	);
+});

package/src/resources/extensions/ollama/tests/ollama-discovery.test.ts

@@ -1 +1,55 @@
 // GSD2 — Tests for Ollama model discovery and enrichment
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { discoverModels } from "../ollama-discovery.js";
+import type { OllamaTagsResponse, OllamaShowResponse } from "../types.js";
+
+const EMPTY_DETAILS = { parent_model: "", format: "", family: "", families: null, parameter_size: "", quantization_level: "" };
+
+function modelStub(name: string, parameterSize = "") {
+	return { name, model: name, modified_at: "", size: 0, digest: "", details: { ...EMPTY_DETAILS, parameter_size: parameterSize } };
+}
+
+function tagsStub(name: string, parameterSize = ""): OllamaTagsResponse {
+	return { models: [modelStub(name, parameterSize)] };
+}
+
+function showStub(modelInfo: Record<string, unknown>): OllamaShowResponse {
+	return { modelfile: "", parameters: "", template: "", details: EMPTY_DETAILS, model_info: modelInfo };
+}
+
+describe("discoverModels — context window resolution", () => {
+	it("uses known table context window without calling /api/show", async () => {
+		let showCalled = false;
+		const models = await discoverModels({
+			listModels: async () => tagsStub("llama3.2:latest", "3B"),
+			showModel: async () => { showCalled = true; throw new Error("should not be called"); },
+		});
+		assert.equal(models[0].contextWindow, 131072);
+		assert.equal(showCalled, false);
+	});
+
+	it("uses context_length from /api/show model_info for unknown model", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("gemini-3-flash-preview:latest"),
+			showModel: async () => showStub({ "gemini.context_length": 1048576 }),
+		});
+		assert.equal(models[0].contextWindow, 1048576);
+	});
+
+	it("falls back to 8192 when /api/show model_info has no context_length key", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("unknown-model:latest"),
+			showModel: async () => showStub({}),
+		});
+		assert.equal(models[0].contextWindow, 8192);
+	});
+
+	it("falls back to 8192 when /api/show throws", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("unknown-model:latest"),
+			showModel: async () => { throw new Error("network error"); },
+		});
+		assert.equal(models[0].contextWindow, 8192);
+	});
+});

package/src/resources/extensions/shared/gsd-phase-state.ts

@@ -0,0 +1,42 @@
+/**
+ * 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: string | null = null;
+
+/** Mark GSD auto-mode as active. */
+export function activateGSD(): void {
+	_active = true;
+}
+
+/** Mark GSD auto-mode as inactive and clear the current phase. */
+export function deactivateGSD(): void {
+	_active = false;
+	_currentPhase = null;
+}
+
+/** Set the currently dispatched GSD phase (e.g. "plan-milestone"). */
+export function setCurrentPhase(phase: string): void {
+	_currentPhase = phase;
+}
+
+/** Clear the current phase (unit completed or aborted). */
+export function clearCurrentPhase(): void {
+	_currentPhase = null;
+}
+
+/** Returns true if GSD auto-mode is currently active. */
+export function isGSDActive(): boolean {
+	return _active;
+}
+
+/** Returns the current GSD phase, or null if none is active. */
+export function getCurrentPhase(): string | null {
+	return _active ? _currentPhase : null;
+}