gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -189,7 +189,22 @@ test("getAllKeyStatuses detects empty keys as not configured", () => {
   const statuses = getAllKeyStatuses(auth);
   const groq = statuses.find((s) => s.provider.id === "groq");
   assert.equal(groq?.configured, false);
-  assert.ok(groq?.description.includes("empty"));
+  // Empty-key entries are filtered out, so provider appears unconfigured
+  assert.equal(groq?.source, "none");
+});
+
+test("getAllKeyStatuses finds valid keys even when empty-key entry exists at index 0", () => {
+  const auth = makeAuth({
+    groq: [
+      { type: "api_key", key: "" },
+      { type: "api_key", key: "gsk-real-key" },
+    ],
+  });
+  const statuses = getAllKeyStatuses(auth);
+  const groq = statuses.find((s) => s.provider.id === "groq");
+  assert.equal(groq?.configured, true);
+  assert.equal(groq?.source, "auth.json");
+  assert.equal(groq?.credentialCount, 1); // only the valid key counts
 });
 
 test("getAllKeyStatuses detects env var keys", () => {

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 12, 'new DB should be at schema version 12');
+  assert.deepStrictEqual(version?.v, 14, 'new DB should be at schema version 14');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

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

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 12 (after quality gates table)
+  // Verify schema version is 14 (after indexes + slice_dependencies)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 12, 'schema version should be 12');
+  assert.deepStrictEqual(version?.['v'], 14, 'schema version should be 14');
 
   closeDatabase();
 });

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

@@ -165,3 +165,43 @@ test("falls back to configured model when no light-tier model available", () =>
   assert.equal(result.modelId, "claude-opus-4-6");
   assert.equal(result.wasDowngraded, false);
 });
+
+// ─── #2192: Unknown models honor explicit config ─────────────────────────────
+
+test("#2192: unknown model is not downgraded — respects user config", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "gpt-5.4", fallbacks: [] },
+    config,
+    ["gpt-5.4", ...AVAILABLE_MODELS],
+  );
+  assert.equal(result.modelId, "gpt-5.4", "unknown model should be used as-is");
+  assert.equal(result.wasDowngraded, false, "should not be downgraded");
+  assert.ok(result.reason.includes("not in the known tier map"), "reason should explain why");
+});
+
+test("#2192: unknown model with provider prefix is not downgraded", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "custom-provider/my-model-v3", fallbacks: [] },
+    config,
+    ["custom-provider/my-model-v3", ...AVAILABLE_MODELS],
+  );
+  assert.equal(result.modelId, "custom-provider/my-model-v3");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("#2192: known model is still downgraded normally", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // claude-opus-4-6 is known as "heavy" — a light request should downgrade
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.wasDowngraded, true, "known heavy model should still be downgraded for light tasks");
+  assert.notEqual(result.modelId, "claude-opus-4-6");
+});

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -8,7 +8,7 @@
  * Uses the writeRunnerPreferences pattern from doctor-git.test.ts:
  * PROJECT_PREFERENCES_PATH is a module-level constant frozen at import
  * time, so process.chdir() won't redirect preference loading. We write
- * prefs to the runner's cwd .gsd/preferences.md and clean up in finally.
+ * prefs to the runner's cwd .gsd/PREFERENCES.md and clean up in finally.
  */
 
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
@@ -24,7 +24,7 @@ import assert from 'node:assert/strict';
 
 // --- Preferences helpers (same pattern as doctor-git.test.ts K001) ---
 
-const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "preferences.md");
+const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "PREFERENCES.md");
 
 function writeRunnerPreferences(isolation: "none" | "worktree" | "branch"): void {
   mkdirSync(join(process.cwd(), ".gsd"), { recursive: true });
@@ -72,12 +72,12 @@ try {
 
 // Test 4: shouldUseWorktreeIsolation returns false for no prefs (default: none)
 // Worktree isolation requires explicit opt-in — default is "none" so GSD
-// works out of the box without preferences.md (#2480).
+// works out of the box without PREFERENCES.md (#2480).
 // Skip if global prefs exist — they override the default and this test
-// cannot control ~/.gsd/preferences.md.
+// cannot control ~/.gsd/PREFERENCES.md.
 
 test('shouldUseWorktreeIsolation returns false for no prefs (default: none)', () => {
-  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "PREFERENCES.md"))
     || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
   if (!globalPrefsExist) {
     try {
@@ -91,9 +91,9 @@ test('shouldUseWorktreeIsolation returns false for no prefs (default: none)', ()
   }
 });
 
-// Test 5: getIsolationMode returns "none" when no preferences.md exists (#2480)
+// Test 5: getIsolationMode returns "none" when no PREFERENCES.md exists (#2480)
 test('getIsolationMode returns "none" with no prefs (default)', () => {
-  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "PREFERENCES.md"))
     || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
   if (!globalPrefsExist) {
     try {

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

@@ -31,7 +31,10 @@ test("shouldSendDesktopNotification disables all categories when notifications a
   assert.equal(shouldSendDesktopNotification("milestone", prefs), false);
 });
 
-test("buildDesktopNotificationCommand uses argument arrays for macOS notifications", () => {
+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.
+  // If terminal-notifier IS installed, we verify it returns that instead.
   const command = buildDesktopNotificationCommand(
     "darwin",
     `Bob's "Milestone"`,
@@ -40,11 +43,30 @@ test("buildDesktopNotificationCommand uses argument arrays for macOS notificatio
   );
 
   assert.ok(command);
-  assert.equal(command.file, "osascript");
-  assert.deepEqual(command.args.slice(0, 1), ["-e"]);
-  assert.match(command.args[1], /Bob's \\"Milestone\\"/);
-  assert.match(command.args[1], /Budget! Path: C:\\\\temp/);
-  assert.doesNotMatch(command.args[1], /\n/);
+  if (command.file.includes("terminal-notifier")) {
+    // terminal-notifier path — verify args structure
+    assert.ok(command.args.includes("-title"));
+    assert.ok(command.args.includes("-message"));
+    assert.ok(command.args.includes("-sound"));
+    assert.ok(command.args.includes("Basso")); // error level
+  } else {
+    // osascript fallback path
+    assert.equal(command.file, "osascript");
+    assert.deepEqual(command.args.slice(0, 1), ["-e"]);
+    assert.match(command.args[1], /Bob's \\"Milestone\\"/);
+    assert.match(command.args[1], /Budget! Path: C:\\\\temp/);
+    assert.doesNotMatch(command.args[1], /\n/);
+  }
+});
+
+test("buildDesktopNotificationCommand uses Glass sound for non-error on macOS", () => {
+  const command = buildDesktopNotificationCommand("darwin", "Title", "Message", "info");
+  assert.ok(command);
+  if (command.file.includes("terminal-notifier")) {
+    assert.ok(command.args.includes("Glass"));
+  } else {
+    assert.match(command.args[1], /sound name "Glass"/);
+  }
 });
 
 test("buildDesktopNotificationCommand preserves literal shell characters on linux", () => {

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Regression test for #2694: parkMilestone and unparkMilestone must
+ * update the DB milestone status alongside the filesystem marker.
+ *
+ * Without this, deriveStateFromDb skips unparked milestones because
+ * the DB still has status='parked', causing "All milestones complete".
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { parkMilestone, unparkMilestone } from "../milestone-actions.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  getMilestone,
+} from "../gsd-db.ts";
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-park-db-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001\n\nContext.",
+  );
+  return base;
+}
+
+test("parkMilestone updates DB status to 'parked' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    assert.equal(getMilestone("M001")!.status, "active", "starts active");
+
+    parkMilestone(base, "M001", "deprioritized");
+
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("unparkMilestone updates DB status to 'active' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    // Park first
+    parkMilestone(base, "M001", "deprioritized");
+    assert.equal(getMilestone("M001")!.status, "parked");
+
+    // Unpark
+    unparkMilestone(base, "M001");
+    assert.equal(getMilestone("M001")!.status, "active", "DB status should be active after unpark");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("park/unpark are safe when DB is not available (#2694 guard)", () => {
+  const base = createBase();
+  try {
+    // No openDatabase — DB not available
+    // park/unpark should still work (filesystem-only, no throw)
+    const parked = parkMilestone(base, "M001", "test");
+    assert.ok(parked, "parkMilestone succeeds without DB");
+
+    const unparked = unparkMilestone(base, "M001");
+    assert.ok(unparked, "unparkMilestone succeeds without DB");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});