gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

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

@@ -1,4 +1,4 @@
-import { parseMemoryResponse, _resetExtractionState } from '../memory-extractor.ts';
+import { parseMemoryResponse, _resetExtractionState, buildMemoryLLMCall } from '../memory-extractor.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -9,7 +9,7 @@ import {
   getActiveMemoriesRanked,
 } from '../memory-store.ts';
 import type { MemoryAction } from '../memory-store.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
+import { describe, test, beforeEach, afterEach, mock } from 'node:test';
 import assert from 'node:assert/strict';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -169,3 +169,86 @@ test('memory-extractor: reset extraction state', () => {
   assert.ok(true, '_resetExtractionState should not throw');
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: buildMemoryLLMCall resolves OAuth API key via modelRegistry
+// Regression test for #2959 — OAuth users had broken memory extraction
+// because streamSimpleAnthropic only checked env vars, not auth.json.
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-extractor: buildMemoryLLMCall resolves API key from modelRegistry for OAuth users', async () => {
+  const OAUTH_TOKEN = 'sk-ant-oat-test-oauth-token-12345';
+  let getApiKeyCalled = false;
+
+  const fakeModel = {
+    id: 'claude-haiku-test',
+    provider: 'anthropic',
+    api: 'anthropic-messages',
+    cost: { input: 0.25, output: 1.25 },
+  };
+
+  const ctx = {
+    modelRegistry: {
+      getAvailable: () => [fakeModel],
+      getApiKey: async (_model: any) => {
+        getApiKeyCalled = true;
+        return OAUTH_TOKEN;
+      },
+    },
+  } as any;
+
+  const llmCallFn = buildMemoryLLMCall(ctx);
+  assert.ok(llmCallFn !== null, 'buildMemoryLLMCall should return a function when models are available');
+
+  // The function should have resolved the API key eagerly via modelRegistry.getApiKey.
+  // Give the async getApiKey a tick to resolve.
+  await new Promise(resolve => setTimeout(resolve, 50));
+  assert.ok(getApiKeyCalled, 'buildMemoryLLMCall must call modelRegistry.getApiKey() to resolve OAuth tokens');
+});
+
+test('memory-extractor: buildMemoryLLMCall returns null when no models available', () => {
+  const ctx = {
+    modelRegistry: {
+      getAvailable: () => [],
+      getApiKey: async () => undefined,
+    },
+  } as any;
+
+  const llmCallFn = buildMemoryLLMCall(ctx);
+  assert.strictEqual(llmCallFn, null, 'should return null when no models available');
+});
+
+test('memory-extractor: buildMemoryLLMCall prefers haiku model', async () => {
+  let resolvedModelId: string | undefined;
+
+  const haikuModel = {
+    id: 'claude-3-5-haiku-20241022',
+    provider: 'anthropic',
+    api: 'anthropic-messages',
+    cost: { input: 0.25, output: 1.25 },
+  };
+  const sonnetModel = {
+    id: 'claude-sonnet-4-20250514',
+    provider: 'anthropic',
+    api: 'anthropic-messages',
+    cost: { input: 3, output: 15 },
+  };
+
+  const ctx = {
+    modelRegistry: {
+      getAvailable: () => [sonnetModel, haikuModel],
+      getApiKey: async (model: any) => {
+        resolvedModelId = model.id;
+        return 'sk-ant-oat-test-token';
+      },
+    },
+  } as any;
+
+  const llmCallFn = buildMemoryLLMCall(ctx);
+  assert.ok(llmCallFn !== null, 'should return a function');
+
+  // Wait for the async getApiKey to resolve
+  await new Promise(resolve => setTimeout(resolve, 50));
+  assert.strictEqual(resolvedModelId, 'claude-3-5-haiku-20241022',
+    'should resolve API key for haiku model, not sonnet');
+});
+

package/src/resources/extensions/gsd/tests/migrate-external-worktree.test.ts

@@ -0,0 +1,105 @@
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  realpathSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { migrateToExternalState } from "../migrate-external.ts";
+
+function run(command: string, cwd: string): string {
+  return execSync(command, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+describe("migrate-external worktree guard (#2970)", () => {
+  let base: string;
+  let stateDir: string;
+  let worktreePath: string;
+
+  before(() => {
+    base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-wt-")));
+    stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-")));
+    process.env.GSD_STATE_DIR = stateDir;
+
+    // Create a git repo with a remote
+    run("git init -b main", base);
+    run('git config user.name "Test"', base);
+    run('git config user.email "test@example.com"', base);
+    run('git remote add origin git@github.com:example/repo.git', base);
+    writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "init"', base);
+
+    // Create a worktree
+    worktreePath = join(base, ".gsd", "worktrees", "M001");
+    run(`git worktree add -b milestone/M001 ${worktreePath}`, base);
+
+    // Populate worktree with a .gsd directory (simulating syncGsdStateToWorktree)
+    const worktreeGsd = join(worktreePath, ".gsd");
+    mkdirSync(worktreeGsd, { recursive: true });
+    writeFileSync(join(worktreeGsd, "PREFERENCES.md"), "# prefs\n", "utf-8");
+  });
+
+  after(() => {
+    delete process.env.GSD_STATE_DIR;
+    // Remove worktree before cleaning up
+    try { run(`git worktree remove --force ${worktreePath}`, base); } catch { /* ok */ }
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  test("migrateToExternalState skips when basePath is a git worktree", () => {
+    // The worktree has a real .gsd directory — migration would normally run.
+    // But since this is a worktree, it should be skipped.
+    const result = migrateToExternalState(worktreePath);
+
+    assert.equal(result.migrated, false, "should not migrate inside a worktree");
+    assert.equal(result.error, undefined, "should not report an error");
+
+    // .gsd should still exist as a real directory (not renamed/removed)
+    assert.ok(
+      existsSync(join(worktreePath, ".gsd")),
+      ".gsd directory should still exist after skipped migration"
+    );
+
+    // .gsd.migrating should NOT exist
+    assert.ok(
+      !existsSync(join(worktreePath, ".gsd.migrating")),
+      ".gsd.migrating should not be created in a worktree"
+    );
+  });
+
+  test("migrateToExternalState still works on main repo", () => {
+    // Create a fresh temp repo to test main repo migration path
+    const mainBase = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-main-")));
+    try {
+      run("git init -b main", mainBase);
+      run('git config user.name "Test"', mainBase);
+      run('git config user.email "test@example.com"', mainBase);
+      run('git remote add origin git@github.com:example/main-repo.git', mainBase);
+      writeFileSync(join(mainBase, "README.md"), "# Test\n", "utf-8");
+      run("git add README.md", mainBase);
+      run('git commit -m "init"', mainBase);
+
+      // Create a .gsd directory with content
+      mkdirSync(join(mainBase, ".gsd"), { recursive: true });
+      writeFileSync(join(mainBase, ".gsd", "PREFERENCES.md"), "# prefs\n", "utf-8");
+
+      const result = migrateToExternalState(mainBase);
+      assert.equal(result.migrated, true, "should migrate on main repo");
+    } finally {
+      rmSync(mainBase, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,116 @@
+/**
+ * Bug #2807: Web roadmap derives milestone status from slice heuristics
+ * instead of authoritative GSD milestone state.
+ *
+ * getMilestoneStatus() should prefer the authoritative `status` field on
+ * WorkspaceMilestoneTarget (populated from the engine registry) rather
+ * than inferring status from slice completion flags.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getMilestoneStatus } from "../../../../../web/lib/workspace-status.ts";
+
+// Inline type to avoid importing .tsx (not compiled to .js by test pipeline)
+interface TestMilestone {
+  id: string;
+  title: string;
+  roadmapPath?: string;
+  status?: "complete" | "active" | "pending" | "parked";
+  validationVerdict?: "pass" | "needs-attention" | "needs-remediation";
+  slices: Array<{ id: string; title: string; done: boolean; tasks: Array<{ id: string; title: string; done: boolean }> }>;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function makeMilestone(overrides: Partial<TestMilestone> & { id: string }): TestMilestone {
+  return {
+    title: overrides.id,
+    roadmapPath: undefined,
+    slices: [],
+    ...overrides,
+  };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+test("getMilestoneStatus returns authoritative 'complete' even when slices are not all done", () => {
+  const milestone = makeMilestone({
+    id: "M001",
+    status: "complete",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+      { id: "S02", title: "Slice 2", done: false, tasks: [] }, // not done
+    ],
+  });
+  // Before the fix, this would return "in-progress" because not all slices are done.
+  // After the fix, it should return "done" because authoritative status is "complete".
+  assert.equal(getMilestoneStatus(milestone, {}), "done");
+});
+
+test("getMilestoneStatus returns authoritative 'active' regardless of slice state", () => {
+  const milestone = makeMilestone({
+    id: "M002",
+    status: "active",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+      { id: "S02", title: "Slice 2", done: true, tasks: [] },
+    ],
+  });
+  // Before the fix, this would return "done" because all slices are done.
+  // After the fix, it should return "in-progress" because authoritative status is "active".
+  assert.equal(getMilestoneStatus(milestone, {}), "in-progress");
+});
+
+test("getMilestoneStatus returns 'pending' for authoritative 'pending' even when some slices done", () => {
+  const milestone = makeMilestone({
+    id: "M003",
+    status: "pending",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+      { id: "S02", title: "Slice 2", done: false, tasks: [] },
+    ],
+  });
+  // Before the fix, this would return "in-progress" because some slices are done.
+  // After the fix, it should return "pending".
+  assert.equal(getMilestoneStatus(milestone, {}), "pending");
+});
+
+test("getMilestoneStatus maps 'parked' to 'pending' item status", () => {
+  const milestone = makeMilestone({
+    id: "M004",
+    status: "parked",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+    ],
+  });
+  // Parked milestones should render as pending in the UI
+  assert.equal(getMilestoneStatus(milestone, {}), "pending");
+});
+
+test("getMilestoneStatus falls back to heuristic when no authoritative status", () => {
+  // Backward compatibility: milestones without the status field should
+  // still work using the old slice-based heuristic.
+  const milestone = makeMilestone({
+    id: "M005",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+      { id: "S02", title: "Slice 2", done: true, tasks: [] },
+    ],
+  });
+  assert.equal(getMilestoneStatus(milestone, {}), "done");
+});
+
+test("getMilestoneStatus exposes validationVerdict on milestone target", () => {
+  const milestone = makeMilestone({
+    id: "M006",
+    status: "complete",
+    validationVerdict: "needs-attention",
+    slices: [
+      { id: "S01", title: "Slice 1", done: true, tasks: [] },
+    ],
+  });
+  // The milestone should have the validationVerdict field available
+  assert.equal(milestone.validationVerdict, "needs-attention");
+  // And status should still be "done"
+  assert.equal(getMilestoneStatus(milestone, {}), "done");
+});

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

@@ -67,3 +67,37 @@ test("all cost table entries have valid data", () => {
     assert.ok(entry.updatedAt, `${entry.id} missing updatedAt`);
   }
 });
+
+// ─── #2885: openai-codex and modern OpenAI models in cost table ──────────────
+
+test("#2885: cost table includes openai-codex provider models", () => {
+  const ids = BUNDLED_COST_TABLE.map(e => e.id);
+  const codexModels = [
+    "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4",
+  ];
+  for (const model of codexModels) {
+    assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
+  }
+});
+
+test("#2885: cost table includes modern OpenAI models", () => {
+  const ids = BUNDLED_COST_TABLE.map(e => e.id);
+  const newModels = [
+    "o4-mini", "o4-mini-deep-research",
+    "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano",
+    "gpt-5", "gpt-5-mini", "gpt-5-nano", "gpt-5-pro",
+  ];
+  for (const model of newModels) {
+    assert.ok(ids.includes(model), `cost table should include modern OpenAI model "${model}"`);
+  }
+});
+
+test("#2885: lookupModelCost returns costs for new models (not 999 fallback)", () => {
+  const newModels = ["o4-mini", "gpt-4.1", "gpt-5", "gpt-5.4", "gpt-5.1-codex-mini"];
+  for (const model of newModels) {
+    const entry = lookupModelCost(model);
+    assert.ok(entry, `lookupModelCost should find "${model}"`);
+    assert.ok(entry.inputPer1k < 999, `${model} should have a real cost, not the 999 fallback`);
+  }
+});

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

@@ -172,11 +172,11 @@ 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: [] },
+    { primary: "some-future-unknown-model-v9", fallbacks: [] },
     config,
-    ["gpt-5.4", ...AVAILABLE_MODELS],
+    ["some-future-unknown-model-v9", ...AVAILABLE_MODELS],
   );
-  assert.equal(result.modelId, "gpt-5.4", "unknown model should be used as-is");
+  assert.equal(result.modelId, "some-future-unknown-model-v9", "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");
 });
@@ -205,3 +205,68 @@ test("#2192: known model is still downgraded normally", () => {
   assert.equal(result.wasDowngraded, true, "known heavy model should still be downgraded for light tasks");
   assert.notEqual(result.modelId, "claude-opus-4-6");
 });
+
+// ─── #2885: openai-codex and modern OpenAI models in tier map ────────────────
+
+test("#2885: openai-codex light-tier models are recognized", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark"];
+  for (const model of lightModels) {
+    const result = resolveModelForComplexity(
+      makeClassification("light"),
+      { primary: model, fallbacks: [] },
+      config,
+      [model, ...AVAILABLE_MODELS],
+    );
+    // Model is known AND light-tier, so requesting light should NOT downgrade
+    assert.equal(result.wasDowngraded, false, `${model} should be known as light tier (wasDowngraded)`);
+    assert.equal(result.modelId, model, `${model} should be returned as-is for light tier`);
+    // Verify it IS known (not hitting the unknown-model bail-out)
+    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
+  }
+});
+
+test("#2885: openai-codex standard-tier models are recognized", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const standardModels = ["gpt-4.1", "gpt-5.1-codex-max"];
+  for (const model of standardModels) {
+    const result = resolveModelForComplexity(
+      makeClassification("standard"),
+      { primary: model, fallbacks: [] },
+      config,
+      [model, ...AVAILABLE_MODELS],
+    );
+    assert.equal(result.wasDowngraded, false, `${model} should be known as standard tier`);
+    assert.equal(result.modelId, model, `${model} should be returned as-is for standard tier`);
+    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
+  }
+});
+
+test("#2885: openai-codex heavy-tier models are recognized", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "o4-mini", "o4-mini-deep-research"];
+  for (const model of heavyModels) {
+    const result = resolveModelForComplexity(
+      makeClassification("heavy"),
+      { primary: model, fallbacks: [] },
+      config,
+      [model, ...AVAILABLE_MODELS],
+    );
+    assert.equal(result.wasDowngraded, false, `${model} should be known as heavy tier`);
+    assert.equal(result.modelId, model, `${model} should be returned as-is for heavy tier`);
+    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
+  }
+});
+
+test("#2885: heavy openai-codex model downgrades to light for light task", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "gpt-5.4", fallbacks: [] },
+    config,
+    ["gpt-5.4", "gpt-4.1-nano", ...AVAILABLE_MODELS],
+  );
+  assert.equal(result.wasDowngraded, true, "heavy model should downgrade for light task");
+  // Should pick a light-tier model
+  assert.notEqual(result.modelId, "gpt-5.4", "should not use the heavy model for light task");
+});

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

@@ -154,6 +154,34 @@ test("all auto-dispatch unitTypes have preference mapping or subagent handling",
   assert.deepEqual(unmapped, [], `Unmapped unitTypes in preferences-models.ts: ${unmapped.join(", ")}`);
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// #2900: worktree-merge must map to completion phase
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("#2900: resolveModelWithFallbacksForUnit handles worktree-merge", () => {
+  assert.ok(preferencesSrc.includes('"worktree-merge"'), "missing worktree-merge case in switch");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// #2900: KNOWN_UNIT_TYPES must include all dispatched unit types
+// ═══════════════════════════════════════════════════════════════════════════
+
+const preferenceTypesSrc = readSrc("preferences-types.ts");
+
+test("#2900: KNOWN_UNIT_TYPES includes all auto-dispatch unit types", () => {
+  const missing: string[] = [];
+  for (const ut of ALL_KNOWN_UNIT_TYPES) {
+    if (!preferenceTypesSrc.includes(`"${ut}"`)) {
+      missing.push(ut);
+    }
+  }
+  assert.deepEqual(missing, [], `Missing from KNOWN_UNIT_TYPES: ${missing.join(", ")}`);
+});
+
+test("#2900: KNOWN_UNIT_TYPES includes worktree-merge", () => {
+  assert.ok(preferenceTypesSrc.includes('"worktree-merge"'), "worktree-merge missing from KNOWN_UNIT_TYPES");
+});
+
 // ═══════════════════════════════════════════════════════════════════════════
 // metrics.ts: classifyUnitPhase coverage
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -4,6 +4,7 @@ import assert from "node:assert/strict";
 import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
+  formatNotificationTitle,
 } from "../notifications.js";
 import type { NotificationPreferences } from "../types.js";
 
@@ -87,3 +88,47 @@ test("buildDesktopNotificationCommand preserves literal shell characters on linu
 test("buildDesktopNotificationCommand skips unsupported platforms", () => {
   assert.equal(buildDesktopNotificationCommand("win32", "Title", "Message"), null);
 });
+
+// ─── formatNotificationTitle — project context in notifications (#2708) ──────
+
+test("formatNotificationTitle returns 'GSD' when no project name is given", () => {
+  assert.equal(formatNotificationTitle(), "GSD");
+  assert.equal(formatNotificationTitle(undefined), "GSD");
+  assert.equal(formatNotificationTitle(""), "GSD");
+});
+
+test("formatNotificationTitle includes project name when provided", () => {
+  assert.equal(formatNotificationTitle("my-app"), "GSD — my-app");
+});
+
+test("formatNotificationTitle trims whitespace from project name", () => {
+  assert.equal(formatNotificationTitle("  spaced  "), "GSD — spaced");
+});
+
+test("buildDesktopNotificationCommand includes project name in title on linux", () => {
+  const command = buildDesktopNotificationCommand(
+    "linux",
+    formatNotificationTitle("my-project"),
+    "All milestones complete!",
+    "success",
+  );
+  assert.ok(command);
+  assert.equal(command.args[2], "GSD — my-project");
+  assert.equal(command.args[3], "All milestones complete!");
+});
+
+test("buildDesktopNotificationCommand includes project name in title on macOS", () => {
+  const command = buildDesktopNotificationCommand(
+    "darwin",
+    formatNotificationTitle("my-project"),
+    "Budget 90%",
+    "warning",
+  );
+  assert.ok(command);
+  if (command.file.includes("terminal-notifier")) {
+    const titleIdx = command.args.indexOf("-title");
+    assert.equal(command.args[titleIdx + 1], "GSD — my-project");
+  } else {
+    assert.match(command.args[1], /GSD — my-project/);
+  }
+});