@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tests/milestone-settlement.test.ts

@@ -0,0 +1,92 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for milestone closeout settlement guidance.
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { evaluateAllCompleteSettlement } from "../milestone-settlement.ts";
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+
+let base = "";
+
+function runGit(cwd: string, args: string[]): void {
+  execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+function initRepo(root: string): void {
+  runGit(root, ["init", "-b", "main"]);
+  runGit(root, ["config", "user.email", "test@example.com"]);
+  runGit(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "README.md"), "# fixture\n");
+  runGit(root, ["add", "."]);
+  runGit(root, ["commit", "-m", "chore: init"]);
+}
+
+function seedClosedMilestone(root: string, worktree: string): void {
+  mkdirSync(join(root, ".gsd"), { recursive: true });
+  openDatabase(join(root, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice One", status: "complete" });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task One",
+    status: "complete",
+    verificationResult: "passed",
+  });
+  insertAssessment({
+    path: ".gsd/milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass\n",
+  });
+
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
+  assert.ok(summaryPath, "complete-milestone summary path should resolve");
+  mkdirSync(dirname(summaryPath), { recursive: true });
+  writeFileSync(summaryPath, "# Milestone One\n\nComplete.\n");
+}
+
+afterEach(() => {
+  try { closeDatabase(); } catch { /* ignore */ }
+  if (base) rmSync(base, { recursive: true, force: true });
+  base = "";
+});
+
+test("merge-pending settlement routes back to complete-milestone dispatch without manual merge guidance", () => {
+  base = mkdtempSync(join(tmpdir(), "gsd-milestone-settlement-"));
+  initRepo(base);
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(dirname(worktree), { recursive: true });
+  runGit(base, ["worktree", "add", "-b", "milestone/M001", worktree, "HEAD"]);
+  seedClosedMilestone(base, worktree);
+
+  const result = evaluateAllCompleteSettlement({
+    milestoneId: "M001",
+    statePhase: "complete",
+    basePath: worktree,
+    originalBasePath: base,
+    milestoneMerged: false,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "merge-pending");
+  assert.equal(result.nextAction, "Retry `/gsd dispatch complete-milestone M001`.");
+  assert.doesNotMatch(result.message, /merge manually/i);
+  assert.doesNotMatch(result.nextAction, /merge manually/i);
+});

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -14,7 +14,7 @@ import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { AutoSession } from "../auto/session.ts";
-import { runPreDispatch } from "../auto/phases.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 
 test("milestone transition archives completed units and rebuilds state", async () => {
   const tempDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cu-reset-")));

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

@@ -429,6 +429,145 @@ test("resolveProfileDefaults: empty availableModelIds falls back to canonical An
   assert.ok(typeof planningModel === "string" && planningModel.startsWith("claude-"));
 });
 
+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("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/notifications.test.ts

@@ -1,7 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+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,
@@ -58,18 +63,68 @@ 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; } };
 
-  assert.match(source, /playNotificationBell\("question"\)/);
-  assert.match(source, /await playQuestionBell\(\)/);
+  await playQuestionBell({ enabled: true, local_bell: true }, stream);
+
+  assert.equal(output, "\u0007");
 });
 
-test("stopAuto plays local bell for auto-mode stop notifications", () => {
-  const source = readFileSync(new URL("../auto.ts", import.meta.url), "utf-8");
+test("playQuestionBell is silent when local bell is disabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
 
-  assert.match(source, /import \{[^}]*playNotificationBell[^}]*\} from "\.\/notifications\.js"/);
-  assert.match(source, /playNotificationBell\("stop", loadedPreferences\?\.notifications\)/);
+  await playQuestionBell({ enabled: true, local_bell: false }, stream);
+
+  assert.equal(output, "");
+});
+
+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("buildDesktopNotificationCommand falls back to osascript on macOS when terminal-notifier is absent", () => {

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);
 });

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";