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

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

@@ -306,6 +306,61 @@ 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" });
+
+    const entries = readNotifications();
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].kind, "auto-stop");
+    assert.equal(entries[0].scope, "M005");
+  });
+
+  test("dedup keys on kind+scope when present, not on prose", () => {
+    initNotificationStore(tmp);
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Rephrased message, same structured identity → deduped within the window
+    appendNotification("Auto-mode blocked — gate rejected", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Same kind, different scope → distinct
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M006" });
+
+    assert.equal(readNotifications().length, 2);
+  });
+
+  test("readNotifications filters by kind and scope", () => {
+    initNotificationStore(tmp);
+    appendNotification("a", "info", "notify", { kind: "auto-stop", scope: "M005" });
+    appendNotification("b", "info", "notify", { kind: "provider-error-pause", scope: "M005" });
+    appendNotification("c", "info");
+
+    assert.equal(readNotifications(tmp, { kind: "auto-stop" }).length, 1);
+    assert.equal(readNotifications(tmp, { scope: "M005" }).length, 2);
+    assert.equal(readNotifications(tmp, { kind: "provider-error-pause", scope: "M005" })[0].message, "b");
+  });
+
   test("listeners are notified on append, markAllRead, and clear", () => {
     initNotificationStore(tmp);
     let calls = 0;

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

@@ -1,11 +1,19 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+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";
 
+import { playQuestionBell } from "../../ask-user-questions.js";
+import { stopAuto } from "../auto.js";
+import { autoSession } from "../auto-runtime-state.js";
 import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
   formatNotificationTitle,
+  launchDesktopNotification,
   playNotificationBell,
   shouldPlayNotificationBell,
 } from "../notifications.js";
@@ -58,18 +66,98 @@ test("playNotificationBell is silent when disabled", () => {
   assert.equal(output, "");
 });
 
-test("ask_user_questions plays local bell before waiting for an answer", () => {
-  const source = readFileSync(new URL("../../ask-user-questions.ts", import.meta.url), "utf-8");
+test("playQuestionBell writes a terminal bell when local bell is enabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
+
+  await playQuestionBell({ enabled: true, local_bell: true }, stream);
+
+  assert.equal(output, "\u0007");
+});
 
-  assert.match(source, /playNotificationBell\("question"\)/);
-  assert.match(source, /await playQuestionBell\(\)/);
+test("playQuestionBell is silent when local bell is disabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
+
+  await playQuestionBell({ enabled: true, local_bell: false }, stream);
+
+  assert.equal(output, "");
 });
 
-test("stopAuto plays local bell for auto-mode stop notifications", () => {
-  const source = readFileSync(new URL("../auto.ts", import.meta.url), "utf-8");
+test("stopAuto plays local bell for auto-mode stop notifications", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stop-bell-"));
+  const previousCwd = process.cwd();
+  const previousStderrWrite = process.stderr.write;
+  const previousStderrIsTTY = process.stderr.isTTY;
+  let bellOutput = "";
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nnotifications:\n  enabled: true\n  local_bell: true\n---\n",
+    "utf-8",
+  );
+
+  process.stderr.isTTY = true;
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    if (typeof chunk === "string") {
+      bellOutput += chunk;
+    }
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    await stopAuto(
+      { hasUI: false, ui: { notify: () => {}, setStatus: () => {}, setWidget: () => {}, setHeader: () => {} } } as any,
+      undefined,
+      "test stop",
+    );
+
+    assert.ok(
+      bellOutput.includes("\u0007"),
+      "stopAuto must write a terminal bell to stderr when the local bell preference is enabled",
+    );
+  } finally {
+    process.stderr.write = previousStderrWrite;
+    process.stderr.isTTY = previousStderrIsTTY;
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+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.match(source, /import \{[^}]*playNotificationBell[^}]*\} from "\.\/notifications\.js"/);
-  assert.match(source, /playNotificationBell\("stop", loadedPreferences\?\.notifications\)/);
+  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", () => {

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

@@ -0,0 +1,179 @@
+/**
+ * OAuth/subscription vs pay-per-token API routing for bare model IDs.
+ *
+ * When the same model ID (e.g. gpt-5.5) exists on multiple providers, resolveModelId
+ * must prefer subscription/OAuth routes over platform API keys.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { MODELS } from "../../../../../packages/pi-ai/dist/models.generated.js";
+import {
+  BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE,
+  resolveModelId,
+} from "../auto-model-selection.js";
+
+type ModelRef = { id: string; provider: string };
+
+function modelsForProviders(modelId: string, providers: string[]): ModelRef[] {
+  return providers.map((provider) => ({ id: modelId, provider }));
+}
+
+/** Table-driven precedence cases — one row per conflict shape, not per model ID. */
+const PRECEDENCE_CASES: Array<{
+  label: string;
+  modelId: string;
+  providers: string[];
+  expected: string;
+  currentProvider?: string;
+}> = [
+  {
+    label: "ChatGPT OAuth beats OpenAI API (gpt-5.5)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "openai-codex"],
+    expected: "openai-codex",
+  },
+  {
+    label: "Codex beats Copilot beats OpenAI API (gpt-5.5 triple)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "github-copilot", "openai-codex"],
+    expected: "openai-codex",
+  },
+  {
+    label: "Copilot OAuth beats OpenAI API when no Codex (gpt-5.5)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "github-copilot"],
+    expected: "github-copilot",
+  },
+  {
+    label: "Copilot OAuth beats OpenAI API (gpt-5-mini)",
+    modelId: "gpt-5-mini",
+    providers: ["openai", "github-copilot"],
+    expected: "github-copilot",
+  },
+  {
+    label: "Anthropic beats Copilot for Claude (claude-sonnet-4-6)",
+    modelId: "claude-sonnet-4-6",
+    providers: ["anthropic", "github-copilot"],
+    expected: "anthropic",
+  },
+  {
+    label: "Copilot beats Google API for Gemini (gemini-2.5-pro)",
+    modelId: "gemini-2.5-pro",
+    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",
+    providers: ["google", "github-copilot", "google-gemini-cli"],
+    expected: "google-gemini-cli",
+  },
+  {
+    label: "Session provider still wins (openai-codex explicit)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "openai-codex", "github-copilot"],
+    expected: "github-copilot",
+    currentProvider: "github-copilot",
+  },
+  {
+    label: "claude-code session beats anthropic (#3772)",
+    modelId: "claude-sonnet-4-6",
+    providers: ["anthropic", "claude-code"],
+    expected: "claude-code",
+    currentProvider: "claude-code",
+  },
+];
+
+for (const row of PRECEDENCE_CASES) {
+  test(`resolveModelId precedence: ${row.label}`, () => {
+    const available = modelsForProviders(row.modelId, row.providers);
+    const result = resolveModelId(row.modelId, available, row.currentProvider);
+    assert.ok(result, `expected a match for ${row.modelId}`);
+    assert.equal(result.provider, row.expected);
+  });
+}
+
+test("BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE covers known OAuth/subscription providers", () => {
+  const expected = [
+    "openai-codex",
+    "google-antigravity",
+    "google-gemini-cli",
+    "anthropic",
+    "github-copilot",
+  ];
+  assert.deepEqual([...BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE], expected);
+});
+
+test("every catalog overlap with OAuth/subscription + API resolves to subscription route", () => {
+  const oauthProviders = new Set(["anthropic", "github-copilot", "openai-codex"]);
+  const subscriptionCli = new Set(["google-gemini-cli", "google-antigravity", "claude-code"]);
+  const apiPayPerToken = new Set(["openai", "google", "azure-openai-responses"]);
+
+  const byId = new Map<string, Set<string>>();
+  for (const [provider, models] of Object.entries(MODELS)) {
+    for (const id of Object.keys(models)) {
+      if (!byId.has(id)) byId.set(id, new Set());
+      byId.get(id)!.add(provider);
+    }
+  }
+
+  const failures: string[] = [];
+
+  for (const [modelId, providers] of byId) {
+    if (providers.size < 2) continue;
+
+    const hasApi = [...providers].some((p) => apiPayPerToken.has(p));
+    const subscriptionCandidates = [...providers].filter(
+      (p) => oauthProviders.has(p) || subscriptionCli.has(p),
+    );
+    if (!hasApi || subscriptionCandidates.length === 0) continue;
+
+    const testProviders = new Set<string>(subscriptionCandidates);
+    for (const p of providers) {
+      if (apiPayPerToken.has(p)) testProviders.add(p);
+    }
+
+    const available = modelsForProviders(modelId, [...testProviders]);
+    const result = resolveModelId(modelId, available, undefined);
+    if (!result) {
+      failures.push(`${modelId}: no resolution among ${[...testProviders].join(", ")}`);
+      continue;
+    }
+
+    const winnerIsSubscription =
+      oauthProviders.has(result.provider) ||
+      subscriptionCli.has(result.provider) ||
+      result.provider === "anthropic";
+
+    if (!winnerIsSubscription) {
+      failures.push(
+        `${modelId}: got ${result.provider}, expected subscription route among ${[...testProviders].join(", ")}`,
+      );
+    }
+  }
+
+  assert.equal(
+    failures.length,
+    0,
+    `catalog overlap routing failures:\n${failures.join("\n")}`,
+  );
+});

package/src/resources/extensions/gsd/tests/observability-validator-boundary.test.ts

@@ -0,0 +1,194 @@
+// Regression tests for issue #912:
+// validatePlanBoundary and validateCompleteBoundary must load all task
+// artifact files and collect issues from every file, not just the first.
+//
+// The bug was sequential await-inside-loop loading; the fix batches reads
+// with Promise.all. These tests assert the observable outcome: issues are
+// returned for every task file present, not only one.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { validatePlanBoundary, validateCompleteBoundary } from "../observability-validator.ts";
+import { clearPathCache, _clearGsdRootCache } from "../paths.ts";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+//
+// Each file is intentionally minimal so it triggers at least one deterministic
+// validation issue (missing ## Steps → empty_steps_section, missing frontmatter
+// observability_surfaces → missing_observability_frontmatter). The exact issue
+// count is not asserted; we only verify that at least one issue refers to each
+// task file path, proving all files were loaded and validated.
+
+const BARE_TASK_PLAN = (id: string) => `# ${id}: Bare Task\n\n## Description\n\nDoes something.\n`;
+
+const BARE_TASK_SUMMARY = (id: string) => `# ${id}-SUMMARY\n\n## Summary\n\nCompleted.\n`;
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Create an isolated temp project root and return its path plus a cleanup
+ * function that clears path caches and removes the directory.
+ */
+function makeProject(): { root: string; cleanup: () => void } {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-obs-boundary-")));
+  return {
+    root,
+    cleanup() {
+      _clearGsdRootCache();
+      clearPathCache();
+      try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+    },
+  };
+}
+
+/**
+ * Create the legacy tasks directory structure inside a temp project root:
+ *   {root}/.gsd/milestones/{mid}/slices/{sid}/tasks/
+ *
+ * Legacy layout is used because flat-phase projects embed tasks as inline
+ * checkboxes in the slice plan file (no tasks/ subdir). The legacy layout
+ * has an explicit tasks/ directory that resolveTasksDir returns.
+ */
+function makeLegacyTasksDir(root: string, mid: string, sid: string): string {
+  const dir = join(root, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+// ── validatePlanBoundary ────────────────────────────────────────────────────
+
+test("#912 validatePlanBoundary: issues collected from every task plan file", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const tasksDir = makeLegacyTasksDir(root, "M001", "S01");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), BARE_TASK_PLAN("T01"), "utf-8");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), BARE_TASK_PLAN("T02"), "utf-8");
+  writeFileSync(join(tasksDir, "T03-PLAN.md"), BARE_TASK_PLAN("T03"), "utf-8");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  // Every task file must appear in at least one issue — proving all three
+  // were loaded. Before the fix only the last file in the loop would be
+  // validated because the loop re-used a stale `content` binding.
+  const paths = new Set(issues.map(i => i.file));
+  assert.ok(
+    paths.size >= 3,
+    `expected issues from at least 3 task plan files, got paths: ${JSON.stringify([...paths])}`,
+  );
+
+  const t01Issues = issues.filter(i => i.file.includes("T01"));
+  const t02Issues = issues.filter(i => i.file.includes("T02"));
+  const t03Issues = issues.filter(i => i.file.includes("T03"));
+  assert.ok(t01Issues.length > 0, "T01-PLAN.md should produce at least one validation issue");
+  assert.ok(t02Issues.length > 0, "T02-PLAN.md should produce at least one validation issue");
+  assert.ok(t03Issues.length > 0, "T03-PLAN.md should produce at least one validation issue");
+});
+
+test("#912 validatePlanBoundary: no issues when tasks directory is empty", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  // Create the tasks dir but leave it empty — no PLAN files.
+  makeLegacyTasksDir(root, "M001", "S01");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  // No slice plan and no task plans → no issues.
+  assert.strictEqual(issues.length, 0, "empty tasks dir should produce no issues");
+});
+
+test("#912 validatePlanBoundary: returns empty array when basePath has no .gsd dir", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  // Don't create any .gsd structure — resolveTasksDir returns null.
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "missing .gsd layout should produce no issues");
+});
+
+// ── validateCompleteBoundary ─────────────────────────────────────────────────
+
+test("#912 validateCompleteBoundary: issues collected from every task summary file", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const tasksDir = makeLegacyTasksDir(root, "M001", "S01");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), BARE_TASK_SUMMARY("T01"), "utf-8");
+  writeFileSync(join(tasksDir, "T02-SUMMARY.md"), BARE_TASK_SUMMARY("T02"), "utf-8");
+  writeFileSync(join(tasksDir, "T03-SUMMARY.md"), BARE_TASK_SUMMARY("T03"), "utf-8");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  // Every task file must appear in at least one issue — proving all three
+  // summary files were loaded in parallel and validated.
+  const paths = new Set(issues.map(i => i.file));
+  assert.ok(
+    paths.size >= 3,
+    `expected issues from at least 3 task summary files, got paths: ${JSON.stringify([...paths])}`,
+  );
+
+  const t01Issues = issues.filter(i => i.file.includes("T01"));
+  const t02Issues = issues.filter(i => i.file.includes("T02"));
+  const t03Issues = issues.filter(i => i.file.includes("T03"));
+  assert.ok(t01Issues.length > 0, "T01-SUMMARY.md should produce at least one validation issue");
+  assert.ok(t02Issues.length > 0, "T02-SUMMARY.md should produce at least one validation issue");
+  assert.ok(t03Issues.length > 0, "T03-SUMMARY.md should produce at least one validation issue");
+});
+
+test("#912 validateCompleteBoundary: no issues when tasks directory is empty", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  makeLegacyTasksDir(root, "M001", "S01");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "empty tasks dir should produce no issues");
+});
+
+test("#912 validateCompleteBoundary: returns empty array when basePath has no .gsd dir", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "missing .gsd layout should produce no issues");
+});

package/src/resources/extensions/gsd/tests/orchestrator-legacy-parity.test.ts

@@ -43,7 +43,7 @@ function makeState(): GSDState {
 
 const fakeCtx = {
   model: { provider: "anthropic", baseUrl: "https://api.anthropic.com", contextWindow: 200_000 },
-  modelRegistry: { getAll: () => [], getProviderAuthMode: (_p: string) => "apiKey" as const },
+  modelRegistry: { getAll: () => [], getAvailable: () => [], getProviderAuthMode: (_p: string) => "apiKey" as const },
 } as never;
 const fakePi = { getActiveTools: () => ["read_file", "write_file"] } as never;
 const BASE = "/tmp/orchestrator-legacy-parity";