@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -297,6 +297,41 @@ test("cross-provider: configured primary available by bare ID wins over equivale
   assert.equal(result.wasDowngraded, false);
 });
 
+test("resolveModelForComplexity: preferred GLM session model wins over cheaper standard-tier GLM models", () => {
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), enabled: true, capability_routing: false };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    "execute-task",
+    undefined,
+    undefined,
+    "zai/glm-5.2",
+  );
+  assert.equal(result.modelId, "zai/glm-5.2");
+  assert.equal(result.selectionMethod, "tier-only");
+});
+
+test("resolveModelForComplexity: wasDowngraded is false when preferred session model matches configuredPrimary with different ID format", () => {
+  // configuredPrimary is bare ("claude-opus-4-6"), preferred comes back as provider-prefixed
+  // ("anthropic/claude-opus-4-6") from availableModelIds. They refer to the same model —
+  // wasDowngraded must NOT be true, which would otherwise trigger a spurious UI notification.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), enabled: true, capability_routing: false };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["anthropic/claude-opus-4-6"],
+    "execute-task",
+    undefined,
+    undefined,
+    "anthropic/claude-opus-4-6",
+  );
+  assert.equal(result.modelId, "anthropic/claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
 // ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
 
 test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
@@ -355,15 +390,68 @@ test("resolveModelForTier: picks light-tier cross-provider model", () => {
   assert.equal(result, "gpt-4o-mini");
 });
 
-test("resolveModelForTier: falls back to canonical when no tier match available", () => {
+test("resolveModelForTier: preserves selected standard-tier model over cheaper same-tier provider models", () => {
+  const result = resolveModelForTier(
+    "standard",
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    defaultRoutingConfig(),
+    true,
+    "zai/glm-5.2",
+  );
+  assert.equal(result, "zai/glm-5.2");
+});
+
+test("resolveModelForTier: light tier with no light provider model stays on selected provider model", () => {
+  try {
+    resetLegacyTelemetry();
+    const result = resolveModelForTier(
+      "light",
+      ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+      defaultRoutingConfig(),
+      true,
+      "zai/glm-5.2",
+    );
+    assert.equal(result, "zai/glm-5.2");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
+  } finally {
+    resetLegacyTelemetry();
+  }
+});
+
+test("resolveModelForTier: cross_provider:false ignores non-Anthropic preferred model and returns Claude", () => {
+  // When dynamic_routing.cross_provider is false, the sameProvider (Claude-only) filter must
+  // win over a non-Anthropic session model — the preferred model must not bypass the restriction.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), cross_provider: false };
+  const result = resolveModelForTier(
+    "standard",
+    ["zai/glm-5.2", "claude-sonnet-4-6"],
+    config,
+    false, // crossProvider=false
+    "zai/glm-5.2",
+  );
+  assert.equal(result, "claude-sonnet-4-6");
+});
+
+test("resolveModelForTier: cross_provider:false honors preferred model when it is a Claude model", () => {
+  // When the session model itself is a Claude model, it should still win within the
+  // same-provider restriction.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), cross_provider: false };
+  const result = resolveModelForTier(
+    "standard",
+    ["anthropic/claude-sonnet-4-6", "anthropic/claude-haiku-4-5"],
+    config,
+    false,
+    "anthropic/claude-sonnet-4-6",
+  );
+  assert.equal(result, "claude-sonnet-4-6");
+});
+
+test("resolveModelForTier: non-empty provider list without a tier match does not fall back to canonical", () => {
   try {
     resetLegacyTelemetry();
-    // Only unknown models available — getModelTier classifies unknowns as
-    // "standard", so a request for "heavy" finds no match and the canonical
-    // Anthropic ID is returned as a documented fallback.
-    const result = resolveModelForTier("heavy", ["some-custom-model"]);
-    assert.equal(result, "claude-opus-4-6");
-    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 1);
+    const result = resolveModelForTier("heavy", ["zai/glm-5.2"]);
+    assert.equal(result, "zai/glm-5.2");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
   } finally {
     resetLegacyTelemetry();
   }
@@ -429,6 +517,254 @@ test("resolveProfileDefaults: empty availableModelIds falls back to canonical An
   assert.ok(typeof planningModel === "string" && planningModel.startsWith("claude-"));
 });
 
+test("resolveProfileDefaults: empty availableModelIds preserves selected model when provided", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults(
+    "balanced",
+    [],
+    defaultRoutingConfig(),
+    "zai/glm-5.2",
+  );
+  assert.equal(defaults.models?.planning, "zai/glm-5.2");
+  assert.equal(defaults.models?.execution, "zai/glm-5.2");
+  assert.equal(defaults.models?.completion, "zai/glm-5.2");
+  assert.equal(defaults.models?.subagent, "zai/glm-5.2");
+});
+
+test("resolveProfileDefaults: selected GLM model wins for standard and light profile slots", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults(
+    "balanced",
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    defaultRoutingConfig(),
+    "zai/glm-5.2",
+  );
+  assert.equal(defaults.models?.planning, "zai/glm-5.2");
+  assert.equal(defaults.models?.execution, "zai/glm-5.2");
+  assert.equal(defaults.models?.completion, "zai/glm-5.2");
+  assert.equal(defaults.models?.subagent, "zai/glm-5.2");
+});
+
+test("loadEffectiveGSDPreferences: balanced profile resolves OpenAI tiers from registry", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-registry-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\ntoken_profile: balanced\n---\n");
+    const { loadEffectiveGSDPreferences, modelIdsForProfileResolution } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+        { provider: "openai-codex", id: "gpt-4o-mini" },
+      ],
+    };
+    const scopedIds = modelIdsForProfileResolution(registry, "openai-codex");
+    const loaded = loadEffectiveGSDPreferences(undefined, {
+      availableModelIds: scopedIds,
+    });
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "gpt-4o");
+    assert.equal(models?.execution, "gpt-4o");
+    assert.equal(models?.completion, "gpt-4o-mini");
+    assert.equal(models?.subagent, "gpt-4o-mini");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced (D046) resolves tiers from registry", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-implicit-balanced-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+        { provider: "openai-codex", id: "gpt-4o-mini" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "openai-codex");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "gpt-4o");
+    assert.equal(models?.completion, "gpt-4o-mini");
+    assert.notEqual(models?.completion, "gemini-2.0-flash");
+    assert.equal(
+      loaded?.preferences.phases?.skip_slice_research,
+      undefined,
+      "implicit balanced model defaults must not silently skip slice research",
+    );
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected GLM model", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-selected-glm-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "zai", id: "glm-4.5-air" },
+        { provider: "zai", id: "glm-5.1" },
+        { provider: "zai", id: "glm-5.2" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "zai", "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected model when scoped registry is empty", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-empty-scope-selected-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "zai", "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+    assert.equal(models?.subagent, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected model when registry is missing", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-missing-registry-selected-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(undefined, undefined, undefined, "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+    assert.equal(models?.subagent, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("modelIdsForProfileResolution: empty anchor scope does not fall back to other providers", async () => {
+  const { modelIdsForProfileResolution } = await import("../preferences.ts");
+  const registry = {
+    getAvailable: () => [
+      { provider: "google", id: "gemini-2.0-flash" },
+      { provider: "openai-codex", id: "gpt-4o" },
+    ],
+  };
+  const scoped = modelIdsForProfileResolution(registry, "openai-codex");
+  assert.deepEqual(scoped, ["openai-codex/gpt-4o"]);
+  const emptyAnchor = modelIdsForProfileResolution(registry, "anthropic");
+  assert.deepEqual(emptyAnchor, []);
+});
+
+test("modelIdsForProfileResolution: honors disabled_model_providers", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-disabled-google-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(
+      join(home, "PREFERENCES.md"),
+      "---\ndisabled_model_providers:\n  - google\n---\n",
+    );
+    const { modelIdsForProfileResolution, resolveDisabledModelProvidersFromPreferences } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+      ],
+    };
+    const disabled = resolveDisabledModelProvidersFromPreferences();
+    const ids = modelIdsForProfileResolution(registry, undefined, disabled);
+    assert.deepEqual(ids, ["openai-codex/gpt-4o"]);
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: anchor provider ignores cheaper Gemini when OpenAI is active", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-anchor-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\ntoken_profile: balanced\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+        { provider: "openai-codex", id: "gpt-4o-mini" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "openai-codex");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "gpt-4o");
+    assert.notEqual(models?.completion, "gemini-2.0-flash");
+    assert.equal(models?.completion, "gpt-4o-mini");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test("resolveProfileDefaults: burn-max omits models so user choice is preserved", async () => {
   const { resolveProfileDefaults } = await import("../preferences-models.js");
   const defaults = resolveProfileDefaults("burn-max", ["gpt-4o"]);

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -306,6 +306,29 @@ describe("notification-store", () => {
     rmSync(lockPath, { force: true });
   });
 
+  test("markAllRead does not busy-spin when a foreign lock is held", (t) => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, "1000", "utf-8");
+
+    let now = 1001;
+    let calls = 0;
+    t.mock.method(Date, "now", () => {
+      calls++;
+      return now++;
+    });
+
+    markAllRead();
+
+    assert.ok(calls <= 2, `expected no retry spin, got ${calls} Date.now calls`);
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+    assert.equal(getUnreadCount(), 0, "best-effort mutation should still run");
+
+    rmSync(lockPath, { force: true });
+  });
+
   test("structured meta persists kind and scope on the entry", () => {
     initNotificationStore(tmp);
     appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });

package/src/resources/extensions/gsd/tests/notifications.test.ts

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import type { ChildProcess } from "node:child_process";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -11,6 +13,7 @@ import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
   formatNotificationTitle,
+  launchDesktopNotification,
   playNotificationBell,
   shouldPlayNotificationBell,
 } from "../notifications.js";
@@ -127,6 +130,36 @@ test("stopAuto plays local bell for auto-mode stop notifications", async () => {
   }
 });
 
+test("launchDesktopNotification starts notifier as detached fire-and-forget process", (t) => {
+  const child = {
+    on(_event: string, _listener: (error: Error) => void) {
+      return child;
+    },
+    unref() {
+      return child;
+    },
+  };
+  const onMock = t.mock.method(child, "on");
+  const unrefMock = t.mock.method(child, "unref");
+  const spawnMock = t.mock.method(
+    childProcess,
+    "spawn",
+    () => child as unknown as ChildProcess,
+  );
+
+  launchDesktopNotification({ file: "notify-send", args: ["Title", "Message"] });
+
+  assert.equal(spawnMock.mock.callCount(), 1);
+  assert.deepEqual(spawnMock.mock.calls[0].arguments, [
+    "notify-send",
+    ["Title", "Message"],
+    { detached: true, stdio: "ignore" },
+  ]);
+  assert.equal(onMock.mock.callCount(), 1);
+  assert.equal(onMock.mock.calls[0].arguments[0], "error");
+  assert.equal(unrefMock.mock.callCount(), 1);
+});
+
 test("buildDesktopNotificationCommand falls back to osascript on macOS when terminal-notifier is absent", () => {
   // When terminal-notifier is not on PATH, falls back to osascript.
   // This test runs in CI where terminal-notifier is typically not installed.

package/src/resources/extensions/gsd/tests/oauth-api-model-routing.test.ts

@@ -63,12 +63,24 @@ const PRECEDENCE_CASES: Array<{
     providers: ["google", "github-copilot"],
     expected: "github-copilot",
   },
+  {
+    label: "Antigravity beats Gemini CLI beats Google API (gemini-2.5-pro)",
+    modelId: "gemini-2.5-pro",
+    providers: ["google", "google-gemini-cli", "google-antigravity"],
+    expected: "google-antigravity",
+  },
   {
     label: "Gemini CLI beats Google API (gemini-2.5-pro)",
     modelId: "gemini-2.5-pro",
     providers: ["google", "google-gemini-cli"],
     expected: "google-gemini-cli",
   },
+  {
+    label: "Antigravity beats Copilot beats Google API",
+    modelId: "gemini-2.5-pro",
+    providers: ["google", "github-copilot", "google-antigravity"],
+    expected: "google-antigravity",
+  },
   {
     label: "Gemini CLI beats Copilot beats Google API",
     modelId: "gemini-2.5-pro",
@@ -103,10 +115,10 @@ for (const row of PRECEDENCE_CASES) {
 test("BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE covers known OAuth/subscription providers", () => {
   const expected = [
     "openai-codex",
+    "google-antigravity",
     "google-gemini-cli",
     "anthropic",
     "github-copilot",
-    "google-antigravity",
   ];
   assert.deepEqual([...BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE], expected);
 });