@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/src/resources/extensions/gsd/tests/auto-migrating-recovery.test.ts

@@ -1,10 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { recoverFailedMigration } from "../migrate-external.ts";
+import { externalGsdRoot } from "../repo-identity.ts";
 
 // Regression tests for #4416: `.gsd.migrating` must be healed before auto-mode
 // proceeds, including on the resume path in auto.ts (fixed at auto.ts:1325).
@@ -48,6 +49,36 @@ test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exi
   assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
 });
 
+test("recoverFailedMigration removes orphan when .gsd is an intact external-state junction", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-orphan-"));
+  const stateDir = mkdtempSync(join(tmpdir(), "gsd-migrating-state-"));
+  const previousStateDir = process.env.GSD_STATE_DIR;
+  const previousProjectId = process.env.GSD_PROJECT_ID;
+  process.env.GSD_STATE_DIR = stateDir;
+  process.env.GSD_PROJECT_ID = "recover-orphan";
+  t.after(() => {
+    if (previousStateDir === undefined) delete process.env.GSD_STATE_DIR;
+    else process.env.GSD_STATE_DIR = previousStateDir;
+    if (previousProjectId === undefined) delete process.env.GSD_PROJECT_ID;
+    else process.env.GSD_PROJECT_ID = previousProjectId;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  const externalPath = externalGsdRoot(base);
+  mkdirSync(join(externalPath, "phases"), { recursive: true });
+  writeFileSync(join(externalPath, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(externalPath, "gsd.db"), "not empty\n", "utf-8");
+  symlinkSync(externalPath, join(base, ".gsd"), "junction");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd junction must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
 test("recoverFailedMigration preserves contents of .gsd.migrating", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-migrating-contents-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

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

@@ -1,8 +1,13 @@
 import { describe, it } 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 { parseMilestoneTarget, parseModelFlag } from "../commands/handlers/auto.js";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 describe("parseMilestoneTarget", () => {
   it("extracts a simple milestone ID", () => {
     const result = parseMilestoneTarget("auto M016");
@@ -60,6 +65,24 @@ describe("parseMilestoneTarget", () => {
   });
 });
 
+describe("auto preference diagnostics", () => {
+  it("notifies preference diagnostics before launching auto-mode", () => {
+    const source = readFileSync(join(__dirname, "..", "commands", "handlers", "auto.ts"), "utf-8");
+    const autoBlockIndex = source.indexOf('if (trimmed === "auto" || trimmed.startsWith("auto "))');
+    assert.ok(autoBlockIndex >= 0, "auto command block should exist");
+    const nextBlockIndex = source.indexOf('if (trimmed === "stop")', autoBlockIndex);
+    const autoBlock = source.slice(autoBlockIndex, nextBlockIndex);
+    const notifyIndex = autoBlock.indexOf("notifyPreferenceDiagnostics");
+    assert.ok(notifyIndex >= 0, "auto command should notify preference diagnostics");
+    for (const match of autoBlock.matchAll(/startAutoDetached/g)) {
+      assert.ok(
+        notifyIndex < match.index!,
+        "preference diagnostics should be notified before each auto-mode launch",
+      );
+    }
+  });
+});
+
 describe("parseModelFlag", () => {
   it("extracts provider/model from --model", () => {
     const result = parseModelFlag("auto --model openrouter/openai/gpt-5.4");

package/src/resources/extensions/gsd/tests/auto-model-selection-tool-poisoning.test.ts

@@ -33,6 +33,7 @@ import {
   selectAndApplyModel,
   ModelPolicyDispatchBlockedError,
   clearToolBaseline,
+  getRegisteredToolSnapshot,
   getToolBaselineSnapshot,
 } from "../auto-model-selection.js";
 import { applyModelPolicyFilter } from "../uok/model-policy.js";
@@ -333,9 +334,12 @@ test("genuinely-impossible (b): cross-provider routing disabled + provider misma
 
     // Set dynamic_routing.cross_provider=false via PREFERENCES so the policy
     // disables cross-provider routing.
+    // burn-max prevents the D046 balanced profile from injecting canonical
+    // anthropic models — without it, source:"explicit" forces allowCrossProvider=true
+    // and the cross-provider guard is bypassed before the test can exercise it.
     writeFileSync(
       join(env.dir, ".gsd", "PREFERENCES.md"),
-      ["---", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
+      ["---", "token_profile: burn-max", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
       "utf-8",
     );
 
@@ -433,9 +437,11 @@ test("restore baseline: setActiveTools(BASELINE) called between units before nex
 test("error carries deny reason fragment from applyModelPolicyFilter", async () => {
   const env = makeTempProject();
   try {
+    // burn-max: prevents D046 balanced default from injecting source:"explicit"
+    // which would force allowCrossProvider=true and bypass cross-provider denial.
     writeFileSync(
       join(env.dir, ".gsd", "PREFERENCES.md"),
-      ["---", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
+      ["---", "token_profile: burn-max", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
       "utf-8",
     );
 
@@ -773,3 +779,20 @@ test("baseline union (#477): getToolBaselineSnapshot includes live tools not pre
     env.cleanup();
   }
 });
+
+test("registered tool snapshot includes tools hidden from the active surface", () => {
+  const pi = {
+    getActiveTools: () => ["read"],
+    getAllTools: () => [
+      { name: "read" },
+      { name: "browser_navigate" },
+      { name: "mcp__gsd-browser__*" },
+    ],
+  };
+
+  assert.deepEqual(getRegisteredToolSnapshot(pi as any), [
+    "read",
+    "browser_navigate",
+    "mcp__gsd-browser__*",
+  ]);
+});

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

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
+import { blockModelUntil, clearTemporaryModelBlocksForTest } from "../blocked-models.ts";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
@@ -25,6 +26,11 @@ test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models
       join(tempProject, ".gsd", "PREFERENCES.md"),
       [
         "---",
+        // burn-max disables profile-based model injection so the synthesis path
+        // (dynamic_routing.tier_models.heavy → primary) is exercised as intended.
+        // Without this, the D046 balanced default injects models.planning and the
+        // function returns source:"explicit" before reaching synthesis.
+        "token_profile: burn-max",
         "dynamic_routing:",
         "  enabled: true",
         "  tier_models:",
@@ -69,6 +75,8 @@ test("resolvePreferredModelConfig falls back to auto start model when heavy tier
       join(tempProject, ".gsd", "PREFERENCES.md"),
       [
         "---",
+        // burn-max: no profile model injection → synthesis path runs
+        "token_profile: burn-max",
         "dynamic_routing:",
         "  enabled: true",
         "  tier_models:",
@@ -223,6 +231,74 @@ test("selectAndApplyModel honors explicit phase models without downgrading (#361
   }
 });
 
+test("selectAndApplyModel skips a rate-limited primary until its reset time", async () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-rate-limit-fallback-project-");
+  const tempGsdHome = makeTempDir("gsd-rate-limit-fallback-home-");
+  const setModelCalls: string[] = [];
+
+  try {
+    clearTemporaryModelBlocksForTest();
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  execution:",
+        "    model: gpt-5.5",
+        "    provider: openai-codex",
+        "    fallbacks:",
+        "      - anthropic/claude-sonnet-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const availableModels = [
+      { id: "gpt-5.5", provider: "openai-codex", api: "responses" },
+      { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+    ];
+    const ctx = {
+      modelRegistry: { getAvailable: () => availableModels },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "openai-codex", id: "gpt-5.5", api: "responses" },
+    } as any;
+    const pi = {
+      setModel: async (model: { provider: string; id: string }) => {
+        setModelCalls.push(`${model.provider}/${model.id}`);
+        return true;
+      },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any;
+
+    blockModelUntil(tempProject, "openai-codex", "gpt-5.5", Date.now() + 60_000, "session limit");
+    await selectAndApplyModel(ctx, pi, "execute-task", "M001/S01/T01", tempProject, undefined, false, { provider: "openai-codex", id: "gpt-5.5" }, undefined, true);
+
+    blockModelUntil(tempProject, "openai-codex", "gpt-5.5", Date.now() - 1, "expired");
+    await selectAndApplyModel(ctx, pi, "execute-task", "M001/S01/T02", tempProject, undefined, false, { provider: "openai-codex", id: "gpt-5.5" }, undefined, true);
+
+    assert.deepEqual(setModelCalls, [
+      "anthropic/claude-sonnet-4-6",
+      "openai-codex/gpt-5.5",
+    ]);
+  } finally {
+    clearTemporaryModelBlocksForTest();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("selectAndApplyModel lets explicit unit models bypass stale cross-provider lock (#116)", async () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -326,6 +402,9 @@ test("selectAndApplyModel escalates dynamic routing tier when retry metadata is
     join(tempProject, ".gsd", "PREFERENCES.md"),
     [
       "---",
+      // burn-max: no profile model injection → synthesis ceiling = heavy tier
+      // → source:"synthesized" → dynamic routing escalation is active on retry
+      "token_profile: burn-max",
       "dynamic_routing:",
       "  enabled: true",
       "  hooks: false",
@@ -803,7 +882,12 @@ test("selectAndApplyModel clamps explicit no-model thinking via ctx.model when r
 
   await selectAndApplyModel(
     {
-      modelRegistry: { getAvailable: () => [] },   // registry lookup fails
+      // Empty registry results force the clamp source to fall back to ctx.model.
+      modelRegistry: {
+        getAvailable: () => [],
+        getAll: () => [],
+        isProviderRequestReady: () => true,
+      },
       sessionManager: { getSessionId: () => "test-session" },
       ui: { notify: () => {} },
       model: ctxModel,
@@ -857,3 +941,25 @@ test("resolveModelId: claude-code wins when session is claude-code regardless of
   assert.ok(result, "should resolve a model");
   assert.equal(result.provider, "claude-code", "claude-code must win when it is the session provider");
 });
+
+test("resolveModelId: openai-codex wins over openai for bare GPT IDs when both are available", () => {
+  const availableModels = [
+    { id: "gpt-5.5", provider: "openai" },
+    { id: "gpt-5.5", provider: "openai-codex" },
+  ];
+
+  const result = resolveModelId("gpt-5.5", availableModels, undefined);
+  assert.ok(result, "should resolve a model");
+  assert.equal(result.provider, "openai-codex", "ChatGPT OAuth must win over platform API for bare IDs");
+});
+
+test("resolveModelId: github-copilot wins over openai when both offer the same GPT model", () => {
+  const availableModels = [
+    { id: "gpt-5.5", provider: "openai" },
+    { id: "gpt-5.5", provider: "github-copilot" },
+  ];
+
+  const result = resolveModelId("gpt-5.5", availableModels, undefined);
+  assert.ok(result);
+  assert.equal(result.provider, "github-copilot");
+});