gsd-pi 2.72.0-dev.3118184 → 2.72.0-dev.4f3264a

package/packages/pi-ai/src/models.generated.test.ts

@@ -1,373 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { MODELS } from "./models.generated.js";
-import { getModel, getModels, getProviders } from "./models.js";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Regression: qwen/qwen3.6-plus missing from OpenRouter (issue #3582)
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("regression #3582 — qwen/qwen3.6-plus available via openrouter", () => {
-	it("qwen/qwen3.6-plus exists in MODELS['openrouter']", () => {
-		const model = MODELS["openrouter"]["qwen/qwen3.6-plus" as keyof (typeof MODELS)["openrouter"]];
-		assert.ok(model, "qwen/qwen3.6-plus must be present in MODELS.openrouter");
-	});
-
-	it("qwen/qwen3.6-plus is accessible via getModel()", () => {
-		const model = getModel("openrouter", "qwen/qwen3.6-plus" as any);
-		assert.ok(model, "getModel('openrouter', 'qwen/qwen3.6-plus') must return a model");
-	});
-
-	it("qwen/qwen3.6-plus has id matching its registry key", () => {
-		const model = getModel("openrouter", "qwen/qwen3.6-plus" as any);
-		assert.equal(model.id, "qwen/qwen3.6-plus");
-	});
-
-	it("qwen/qwen3.6-plus has provider set to openrouter", () => {
-		const model = getModel("openrouter", "qwen/qwen3.6-plus" as any);
-		assert.equal(model.provider, "openrouter");
-	});
-
-	it("qwen/qwen3.6-plus has reasoning enabled", () => {
-		const model = getModel("openrouter", "qwen/qwen3.6-plus" as any);
-		assert.equal(model.reasoning, true, "Qwen3.6 Plus is a reasoning model");
-	});
-
-	it("qwen/qwen3.6-plus has 1M context window", () => {
-		const model = getModel("openrouter", "qwen/qwen3.6-plus" as any);
-		assert.equal(model.contextWindow, 1_000_000);
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Regression: z-ai/glm-5.1 missing from OpenRouter (issue #4069)
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("regression #4069 — z-ai/glm-5.1 available via openrouter", () => {
-	it("z-ai/glm-5.1 exists in MODELS['openrouter']", () => {
-		const model = MODELS["openrouter"]["z-ai/glm-5.1" as keyof (typeof MODELS)["openrouter"]];
-		assert.ok(model, "z-ai/glm-5.1 must be present in MODELS.openrouter");
-	});
-
-	it("z-ai/glm-5.1 is accessible via getModel()", () => {
-		const model = getModel("openrouter", "z-ai/glm-5.1" as any);
-		assert.ok(model, "getModel('openrouter', 'z-ai/glm-5.1') must return a model");
-	});
-
-	it("z-ai/glm-5.1 has id matching its registry key", () => {
-		const model = getModel("openrouter", "z-ai/glm-5.1" as any);
-		assert.equal(model.id, "z-ai/glm-5.1");
-	});
-
-	it("z-ai/glm-5.1 has provider set to openrouter", () => {
-		const model = getModel("openrouter", "z-ai/glm-5.1" as any);
-		assert.equal(model.provider, "openrouter");
-	});
-
-	it("z-ai/glm-5.1 has a positive context window", () => {
-		const model = getModel("openrouter", "z-ai/glm-5.1" as any);
-		assert.ok(model.contextWindow > 0);
-	});
-
-	it("z-ai/glm-5.1 uses the OpenRouter base URL", () => {
-		const model = getModel("openrouter", "z-ai/glm-5.1" as any);
-		assert.equal(model.baseUrl, "https://openrouter.ai/api/v1");
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Structural invariants — every model in MODELS must be well-formed
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("MODELS structural invariants", () => {
-	type ModelEntry = { providerKey: string; modelKey: string; model: Record<string, unknown> };
-
-	function allModels(): ModelEntry[] {
-		const entries: ModelEntry[] = [];
-		for (const [providerKey, providerModels] of Object.entries(MODELS)) {
-			for (const [modelKey, model] of Object.entries(providerModels)) {
-				entries.push({ providerKey, modelKey, model: model as Record<string, unknown> });
-			}
-		}
-		return entries;
-	}
-
-	it("every model's id field matches its key in MODELS", () => {
-		const mismatches: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (model["id"] !== modelKey) {
-				mismatches.push(`${providerKey}/${modelKey}: id="${model["id"]}"`);
-			}
-		}
-		assert.deepEqual(mismatches, [], `Models where 'id' doesn't match registry key:\n  ${mismatches.join("\n  ")}`);
-	});
-
-	it("every model's provider field matches its parent provider key", () => {
-		const mismatches: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (model["provider"] !== providerKey) {
-				mismatches.push(`${providerKey}/${modelKey}: provider="${model["provider"]}"`);
-			}
-		}
-		assert.deepEqual(mismatches, [], `Models where 'provider' doesn't match parent key:\n  ${mismatches.join("\n  ")}`);
-	});
-
-	it("every model has a non-empty string name", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (typeof model["name"] !== "string" || model["name"].trim() === "") {
-				invalid.push(`${providerKey}/${modelKey}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with missing or empty name:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model has a non-empty string api", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (typeof model["api"] !== "string" || model["api"].trim() === "") {
-				invalid.push(`${providerKey}/${modelKey}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with missing or empty api:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model's baseUrl starts with https:// (or is empty for azure-openai-responses)", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (providerKey === "azure-openai-responses") continue;
-			const url = model["baseUrl"];
-			if (typeof url !== "string" || !url.startsWith("https://")) {
-				invalid.push(`${providerKey}/${modelKey}: baseUrl="${url}"`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with missing or non-HTTPS baseUrl:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("azure-openai-responses models have an empty baseUrl (runtime-configured)", () => {
-		const models = getModels("azure-openai-responses");
-		assert.ok(models.length > 0, "azure-openai-responses must have at least one model");
-		for (const model of models) {
-			assert.equal(model.baseUrl, "", `azure-openai-responses/${model.id} should have empty baseUrl`);
-		}
-	});
-
-	it("every model has a boolean reasoning field", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (typeof model["reasoning"] !== "boolean") {
-				invalid.push(`${providerKey}/${modelKey}: reasoning=${model["reasoning"]}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with non-boolean reasoning:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model has a non-empty input array", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			const input = model["input"];
-			if (!Array.isArray(input) || input.length === 0) {
-				invalid.push(`${providerKey}/${modelKey}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with missing or empty input array:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model has a positive contextWindow", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			const cw = model["contextWindow"];
-			if (typeof cw !== "number" || cw <= 0 || !Number.isFinite(cw)) {
-				invalid.push(`${providerKey}/${modelKey}: contextWindow=${cw}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with invalid contextWindow:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model has a positive maxTokens", () => {
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			const mt = model["maxTokens"];
-			if (typeof mt !== "number" || mt <= 0 || !Number.isFinite(mt)) {
-				invalid.push(`${providerKey}/${modelKey}: maxTokens=${mt}`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with invalid maxTokens:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model's maxTokens does not exceed contextWindow", () => {
-		const knownExceptions = new Set([
-			"openrouter/meta-llama/llama-3-8b-instruct",
-			"openrouter/nex-agi/deepseek-v3.1-nex-n1",
-			"openrouter/openai/gpt-3.5-turbo-0613",
-			"openrouter/z-ai/glm-5",
-		]);
-
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (knownExceptions.has(`${providerKey}/${modelKey}`)) continue;
-			const cw = model["contextWindow"] as number;
-			const mt = model["maxTokens"] as number;
-			if (typeof cw === "number" && typeof mt === "number" && mt > cw) {
-				invalid.push(`${providerKey}/${modelKey}: maxTokens(${mt}) > contextWindow(${cw})`);
-			}
-		}
-		assert.deepEqual(invalid, [], `Models where maxTokens exceeds contextWindow:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("every model has a cost object with non-negative numeric fields", () => {
-		const knownNegativeCostModels = new Set([
-			"openrouter/openrouter/auto",
-		]);
-
-		const invalid: string[] = [];
-		for (const { providerKey, modelKey, model } of allModels()) {
-			if (knownNegativeCostModels.has(`${providerKey}/${modelKey}`)) continue;
-			const cost = model["cost"] as Record<string, unknown> | undefined;
-			if (!cost || typeof cost !== "object") {
-				invalid.push(`${providerKey}/${modelKey}: missing cost object`);
-				continue;
-			}
-			for (const field of ["input", "output", "cacheRead", "cacheWrite"] as const) {
-				const val = cost[field];
-				if (typeof val !== "number" || val < 0 || !Number.isFinite(val)) {
-					invalid.push(`${providerKey}/${modelKey}: cost.${field}=${val}`);
-				}
-			}
-		}
-		assert.deepEqual(invalid, [], `Models with invalid cost fields:\n  ${invalid.join("\n  ")}`);
-	});
-
-	it("no provider has duplicate model IDs", () => {
-		const duplicates: string[] = [];
-		for (const [providerKey, providerModels] of Object.entries(MODELS)) {
-			const ids = Object.values(providerModels).map((m) => (m as Record<string, unknown>)["id"] as string);
-			const seen = new Set<string>();
-			for (const id of ids) {
-				if (seen.has(id)) duplicates.push(`${providerKey}/${id}`);
-				seen.add(id);
-			}
-		}
-		assert.deepEqual(duplicates, [], `Duplicate model IDs within a provider:\n  ${duplicates.join("\n  ")}`);
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Registry shape
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("MODELS registry shape", () => {
-	it("has exactly 23 providers", () => {
-		const count = Object.keys(MODELS).length;
-		assert.equal(count, 23, `Expected 23 providers, got ${count}: ${Object.keys(MODELS).join(", ")}`);
-	});
-
-	it("has at least 200 models in total (sanity check)", () => {
-		let total = 0;
-		for (const providerModels of Object.values(MODELS)) {
-			total += Object.keys(providerModels).length;
-		}
-		assert.ok(total >= 200, `Registry has only ${total} models — unexpectedly small`);
-	});
-
-	it("all 23 expected providers are present", () => {
-		const expected = [
-			"amazon-bedrock",
-			"anthropic",
-			"azure-openai-responses",
-			"cerebras",
-			"github-copilot",
-			"google",
-			"google-antigravity",
-			"google-gemini-cli",
-			"google-vertex",
-			"groq",
-			"huggingface",
-			"kimi-coding",
-			"minimax",
-			"minimax-cn",
-			"mistral",
-			"openai",
-			"openai-codex",
-			"opencode",
-			"opencode-go",
-			"openrouter",
-			"vercel-ai-gateway",
-			"xai",
-			"zai",
-		];
-		const actual = Object.keys(MODELS).sort();
-		assert.deepEqual(actual, expected.sort());
-	});
-
-	it("getProviders() returns all generated providers", () => {
-		const providers = getProviders();
-		for (const p of Object.keys(MODELS)) {
-			assert.ok(providers.includes(p as any), `getProviders() missing generated provider: ${p}`);
-		}
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Removed models must not exist
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("removed models are absent from the registry", () => {
-	const removedModels: Array<{ provider: string; id: string }> = [
-		{ provider: "openrouter", id: "anthropic/claude-3.5-sonnet" },
-		{ provider: "openrouter", id: "anthropic/claude-3.5-sonnet-20240620" },
-		{ provider: "openrouter", id: "mistralai/mistral-small-24b-instruct-2501" },
-		{ provider: "openrouter", id: "mistralai/mistral-small-3.1-24b-instruct:free" },
-		{ provider: "openrouter", id: "qwen/qwen3-4b:free" },
-		{ provider: "openrouter", id: "stepfun/step-3.5-flash:free" },
-		{ provider: "openrouter", id: "x-ai/grok-4.20-beta" },
-		{ provider: "openrouter", id: "arcee-ai/trinity-mini:free" },
-		{ provider: "openrouter", id: "google/gemini-3-pro-preview" },
-		{ provider: "openrouter", id: "kwaipilot/kat-coder-pro" },
-		{ provider: "openrouter", id: "meituan/longcat-flash-thinking" },
-		{ provider: "vercel-ai-gateway", id: "xai/grok-2-vision" },
-		{ provider: "anthropic", id: "claude-3-7-sonnet-latest" },
-	];
-
-	for (const { provider, id } of removedModels) {
-		it(`${provider}/${id} has been removed`, () => {
-			const model = getModel(provider as any, id as any);
-			assert.equal(model, undefined, `${provider}/${id} should be removed but is still present`);
-		});
-	}
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Spot-checks for notable models added in this regeneration
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("spot-checks for models added in this regeneration", () => {
-	const newModels: Array<{ provider: string; id: string; reasoning?: boolean }> = [
-		{ provider: "openrouter", id: "z-ai/glm-5.1" },
-		{ provider: "openrouter", id: "z-ai/glm-5v-turbo" },
-		{ provider: "openrouter", id: "google/gemma-4-31b-it" },
-		{ provider: "openrouter", id: "google/gemma-4-26b-a4b-it" },
-		{ provider: "openrouter", id: "arcee-ai/trinity-large-thinking", reasoning: true },
-		{ provider: "openrouter", id: "openai/gpt-audio" },
-		{ provider: "openrouter", id: "anthropic/claude-opus-4.6-fast" },
-		{ provider: "openrouter", id: "qwen/qwen3.6-plus" },
-		{ provider: "groq", id: "groq/compound" },
-		{ provider: "groq", id: "groq/compound-mini" },
-		{ provider: "huggingface", id: "zai-org/GLM-5.1" },
-		{ provider: "openai", id: "gpt-5.3-chat-latest" },
-		{ provider: "mistral", id: "mistral-small-2603" },
-		{ provider: "zai", id: "glm-5.1" },
-	];
-
-	for (const { provider, id, reasoning } of newModels) {
-		it(`${provider}/${id} is present in the registry`, () => {
-			const model = getModel(provider as any, id as any);
-			assert.ok(model, `Expected ${provider}/${id} to be present after regeneration`);
-			assert.equal(model.id, id);
-			assert.equal(model.provider, provider);
-			if (reasoning !== undefined) {
-				assert.equal(model.reasoning, reasoning, `${id} reasoning should be ${reasoning}`);
-			}
-		});
-	}
-});

package/src/resources/extensions/gsd/definition-io.ts

@@ -1,18 +0,0 @@
-/**
- * definition-io.ts — Read frozen DEFINITION.yaml from a run directory.
- *
- * Extracted from custom-workflow-engine.ts to break the circular dependency
- * between context-injector.ts and custom-workflow-engine.ts.
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { parse } from "yaml";
-import type { WorkflowDefinition } from "./definition-loader.js";
-
-/** Read and parse the frozen DEFINITION.yaml from a run directory. */
-export function readFrozenDefinition(runDir: string): WorkflowDefinition {
-  const defPath = join(runDir, "DEFINITION.yaml");
-  const raw = readFileSync(defPath, "utf-8");
-  return parse(raw, { schema: "core" }) as WorkflowDefinition;
-}

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -1,27 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoSource = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
-
-test("#3370: cleanupAfterLoopExit preserves paused auto badge after provider pause", () => {
-  const cleanupIdx = autoSource.indexOf("function cleanupAfterLoopExit");
-  assert.ok(cleanupIdx > -1, "auto.ts should define cleanupAfterLoopExit");
-
-  const dispatchIdx = autoSource.indexOf("export async function dispatchHookUnit", cleanupIdx);
-  assert.ok(dispatchIdx > cleanupIdx, "cleanupAfterLoopExit body should be bounded by the next export");
-
-  const cleanupBody = autoSource.slice(cleanupIdx, dispatchIdx);
-  const pausedGuardIdx = cleanupBody.indexOf("if (!s.paused) {");
-  const clearStatusIdx = cleanupBody.indexOf('ctx.ui.setStatus("gsd-auto", undefined);');
-
-  assert.ok(pausedGuardIdx > -1, "loop-exit cleanup must guard UI clearing when auto is paused");
-  assert.ok(clearStatusIdx > pausedGuardIdx, "status clearing must live behind the paused guard");
-  assert.ok(
-    autoSource.includes('ctx?.ui.setStatus("gsd-auto", "paused");'),
-    "pauseAuto must still set the paused badge for transient provider pauses",
-  );
-});

package/src/resources/extensions/gsd/tests/block-db-writes.test.ts

@@ -1,63 +0,0 @@
-/**
- * Regression test for #3674 — block direct writes to gsd.db
- *
- * When gsd_complete_task was unavailable, agents fell back to shell-based
- * sqlite3 writes, corrupting the WAL-backed database. The fix extends
- * write-intercept to block file writes and bash commands targeting gsd.db.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { isBlockedStateFile, isBashWriteToStateFile } from '../write-intercept.ts';
-
-describe('isBlockedStateFile blocks gsd.db paths (#3674)', () => {
-  test('blocks .gsd/gsd.db', () => {
-    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db'));
-  });
-
-  test('blocks .gsd/gsd.db-wal', () => {
-    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db-wal'));
-  });
-
-  test('blocks .gsd/gsd.db-shm', () => {
-    assert.ok(isBlockedStateFile('/project/.gsd/gsd.db-shm'));
-  });
-
-  test('blocks resolved symlink path under .gsd/projects/', () => {
-    assert.ok(isBlockedStateFile('/home/user/.gsd/projects/myproj/gsd.db'));
-  });
-
-  test('still blocks STATE.md', () => {
-    assert.ok(isBlockedStateFile('/project/.gsd/STATE.md'));
-  });
-
-  test('does not block other .gsd files', () => {
-    assert.ok(!isBlockedStateFile('/project/.gsd/DECISIONS.md'));
-  });
-});
-
-describe('isBashWriteToStateFile blocks DB shell commands (#3674)', () => {
-  test('blocks sqlite3 targeting gsd.db', () => {
-    assert.ok(isBashWriteToStateFile('sqlite3 .gsd/gsd.db "INSERT INTO ..."'));
-  });
-
-  test('blocks better-sqlite3 targeting gsd.db', () => {
-    assert.ok(isBashWriteToStateFile('node -e "require(\'better-sqlite3\')(\'.gsd/gsd.db\')"'));
-  });
-
-  test('blocks shell redirect to gsd.db', () => {
-    assert.ok(isBashWriteToStateFile('echo data > .gsd/gsd.db'));
-  });
-
-  test('blocks cp to gsd.db', () => {
-    assert.ok(isBashWriteToStateFile('cp backup.db .gsd/gsd.db'));
-  });
-
-  test('blocks mv to gsd.db', () => {
-    assert.ok(isBashWriteToStateFile('mv temp.db .gsd/gsd.db'));
-  });
-
-  test('does not block reading gsd.db with cat', () => {
-    assert.ok(!isBashWriteToStateFile('cat .gsd/gsd.db'));
-  });
-});

package/src/resources/extensions/gsd/tests/definition-io.test.ts

@@ -1,57 +0,0 @@
-/**
- * definition-io.ts — unit tests for readFrozenDefinition.
- */
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { readFrozenDefinition } from "../definition-io.ts";
-
-function createTmpDir(): string {
-  return realpathSync(mkdtempSync(join(tmpdir(), "gsd-defio-test-")));
-}
-
-describe("readFrozenDefinition", () => {
-  let runDir: string;
-
-  beforeEach(() => {
-    runDir = createTmpDir();
-  });
-
-  afterEach(() => {
-    rmSync(runDir, { recursive: true, force: true });
-  });
-
-  test("parses a valid DEFINITION.yaml", () => {
-    const yaml = [
-      "version: 1",
-      "name: test-workflow",
-      "description: A test workflow",
-      "steps:",
-      "  - id: step-1",
-      "    prompt: do the thing",
-    ].join("\n");
-    writeFileSync(join(runDir, "DEFINITION.yaml"), yaml, "utf-8");
-
-    const def = readFrozenDefinition(runDir);
-    assert.equal(def.version, 1);
-    assert.equal(def.name, "test-workflow");
-    assert.equal(def.description, "A test workflow");
-    assert.equal(def.steps.length, 1);
-    assert.equal(def.steps[0].id, "step-1");
-  });
-
-  test("throws when DEFINITION.yaml is missing", () => {
-    assert.throws(() => readFrozenDefinition(runDir), {
-      code: "ENOENT",
-    });
-  });
-
-  test("throws on malformed YAML", () => {
-    writeFileSync(join(runDir, "DEFINITION.yaml"), ": : : not valid yaml [", "utf-8");
-    assert.throws(() => readFrozenDefinition(runDir));
-  });
-});

package/src/resources/extensions/gsd/tests/doctor-heal-fixable-warnings.test.ts

@@ -1,14 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { isDoctorHealActionable } from "../commands-handlers.js";
-
-test("doctor heal actionable filter keeps fixable warnings and errors", () => {
-  assert.equal(isDoctorHealActionable({ fixable: true, severity: "warning" }), true);
-  assert.equal(isDoctorHealActionable({ fixable: true, severity: "error" }), true);
-});
-
-test("doctor heal actionable filter excludes info and non-fixable issues", () => {
-  assert.equal(isDoctorHealActionable({ fixable: true, severity: "info" }), false);
-  assert.equal(isDoctorHealActionable({ fixable: false, severity: "warning" }), false);
-  assert.equal(isDoctorHealActionable({ fixable: false, severity: "error" }), false);
-});

package/src/resources/extensions/gsd/tests/false-degraded-mode-warning.test.ts

@@ -1,104 +0,0 @@
-/**
- * false-degraded-mode-warning.test.ts — Regression tests for #3922.
- *
- * Before this fix, deriveState() logged a "DB unavailable — degraded mode"
- * warning even when the DB simply hadn't been opened yet (e.g. during
- * before_agent_start context injection). The fix introduces wasDbOpenAttempted()
- * to distinguish "not yet initialized" from "genuinely unavailable."
- *
- * Two aspects:
- * 1. gsd-db: wasDbOpenAttempted() tracks whether openDatabase() was ever called.
- * 2. state: the degraded-mode warning is gated behind wasDbOpenAttempted().
- */
-
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  wasDbOpenAttempted,
-} from "../gsd-db.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// 1. gsd-db: wasDbOpenAttempted flag
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("wasDbOpenAttempted (#3922)", () => {
-
-  test("wasDbOpenAttempted returns true after openDatabase is called", () => {
-    // By this point in the test suite, openDatabase may or may not have been
-    // called by other tests. So we call it explicitly and verify it returns true.
-    openDatabase(":memory:");
-    assert.strictEqual(wasDbOpenAttempted(), true,
-      "wasDbOpenAttempted should be true after openDatabase call");
-    closeDatabase();
-  });
-
-  test("openDatabase sets the flag even if it fails on invalid path", () => {
-    // openDatabase with an unreachable path may fail, but the flag should
-    // still be set because the attempt was made.
-    try { openDatabase("/nonexistent/path/that/will/fail.db"); } catch { /* expected */ }
-    assert.strictEqual(wasDbOpenAttempted(), true,
-      "wasDbOpenAttempted should be true even after a failed open attempt");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// 2. state.ts: degraded-mode warning is gated behind wasDbOpenAttempted
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("degraded-mode warning guard (#3922)", () => {
-
-  test("state.ts imports wasDbOpenAttempted from gsd-db", () => {
-    assert.ok(
-      stateSource.includes("wasDbOpenAttempted"),
-      "state.ts must import wasDbOpenAttempted to gate the degraded-mode warning",
-    );
-  });
-
-  test("degraded-mode warning is inside a wasDbOpenAttempted() guard", () => {
-    // Find the degraded-mode warning string
-    const warningStr = 'DB unavailable — using filesystem state derivation (degraded mode)';
-    const warningIdx = stateSource.indexOf(warningStr);
-    assert.ok(warningIdx > 0, "degraded-mode warning string must exist in state.ts");
-
-    // The wasDbOpenAttempted() check must appear BEFORE the warning,
-    // within the same else-branch (i.e. within a reasonable distance).
-    // Look backwards from the warning for the guard.
-    const searchWindow = stateSource.slice(Math.max(0, warningIdx - 300), warningIdx);
-    assert.ok(
-      searchWindow.includes("wasDbOpenAttempted()"),
-      "wasDbOpenAttempted() guard must appear shortly before the degraded-mode warning " +
-      "to prevent false warnings when DB has not been initialized yet",
-    );
-  });
-
-  test("warning is NOT emitted unconditionally in the else branch", () => {
-    // The old code had `logWarning(...)` directly in the else branch.
-    // The fix wraps it in `if (wasDbOpenAttempted())`.
-    // Verify the logWarning call is inside a conditional, not bare.
-    const lines = stateSource.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i]!.includes("DB unavailable") && lines[i]!.includes("degraded mode")) {
-        // This line has the warning. Check that the preceding non-empty line
-        // contains an if-condition (wasDbOpenAttempted), not a bare else.
-        let prev = i - 1;
-        while (prev >= 0 && lines[prev]!.trim() === "") prev--;
-        const prevLine = lines[prev]!.trim();
-        assert.ok(
-          prevLine.includes("wasDbOpenAttempted"),
-          `Line ${i + 1} emits degraded-mode warning — preceding line ${prev + 1} must ` +
-          `contain wasDbOpenAttempted guard, but found: "${prevLine}"`,
-        );
-        break;
-      }
-    }
-  });
-});