gsd-pi 2.18.0 → 2.20.0

package/dist/resources/extensions/gsd/tests/milestone-transition-worktree.test.ts

@@ -0,0 +1,144 @@
+/**
+ * milestone-transition-worktree.test.ts — Tests for #616 fix.
+ *
+ * Verifies that when auto-mode transitions between milestones, the
+ * worktree lifecycle is handled: old worktree merged, new worktree created.
+ *
+ * Uses source-level checks since the full auto-mode dispatch loop
+ * requires the @gsd/pi-coding-agent runtime.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  isInAutoWorktree,
+  getAutoWorktreeOriginalBase,
+  mergeMilestoneToMain,
+} from "../auto-worktree.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-mt-wt-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function createMilestoneArtifacts(dir: string, mid: string): void {
+  const msDir = join(dir, ".gsd", "milestones", mid);
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "CONTEXT.md"), `# ${mid} Context\n`);
+  const roadmap = [
+    `# ${mid}: Test Milestone`,
+    "**Vision**: testing",
+    "## Success Criteria",
+    "- It works",
+    "## Slices",
+    "- [x] S01 — First slice",
+  ].join("\n");
+  writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
+}
+
+// ─── Milestone transition: worktree swap ─────────────────────────────────────
+
+test("worktree swap on milestone transition: merge old, create new", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Set up M001 and M002 milestone artifacts
+    createMilestoneArtifacts(tempDir, "M001");
+    createMilestoneArtifacts(tempDir, "M002");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestones\"", tempDir);
+
+    // Phase 1: Create worktree for M001 (simulates auto-mode start)
+    const wt1 = createAutoWorktree(tempDir, "M001");
+    assert.equal(process.cwd(), wt1, "cwd should be in M001 worktree");
+    assert.ok(isInAutoWorktree(tempDir), "should be in auto-worktree");
+    assert.equal(getAutoWorktreeOriginalBase(), tempDir, "original base preserved");
+
+    // Add a commit in M001 worktree to simulate work
+    writeFileSync(join(wt1, "feature-m001.txt"), "M001 work\n");
+    run("git add .", wt1);
+    run("git commit -m \"feat(M001): add feature\"", wt1);
+
+    // Phase 2: Simulate milestone transition — merge M001, exit worktree
+    const roadmapPath = join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmapContent = readFileSync(roadmapPath, "utf-8");
+    mergeMilestoneToMain(tempDir, "M001", roadmapContent);
+
+    // After merge: cwd should be back at project root
+    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
+    assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree after merge");
+
+    // Verify M001 work was merged to main
+    const mainLog = run("git log --oneline -3", tempDir);
+    assert.ok(mainLog.includes("M001"), "M001 squash commit should be on main");
+
+    // Phase 3: Create new worktree for M002 (simulates new milestone)
+    const wt2 = createAutoWorktree(tempDir, "M002");
+    assert.equal(process.cwd(), wt2, "cwd should be in M002 worktree");
+    assert.ok(isInAutoWorktree(tempDir), "should be in M002 auto-worktree");
+
+    // The new worktree should have the M001 feature file (merged to main)
+    assert.ok(existsSync(join(wt2, "feature-m001.txt")), "M002 worktree inherits M001 merged work");
+
+    // Verify branch is correct
+    const branch = run("git branch --show-current", wt2);
+    assert.equal(branch, "milestone/M002", "M002 worktree on correct branch");
+
+    // Cleanup
+    teardownAutoWorktree(tempDir, "M002");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});
+
+// ─── Verify the transition code path exists in auto.ts ──────────────────────
+
+test("auto.ts milestone transition block contains worktree lifecycle", () => {
+  const autoSrc = readFileSync(
+    join(__dirname, "..", "auto.ts"),
+    "utf-8",
+  );
+
+  // The fix adds worktree merge + create inside the milestone transition block
+  assert.ok(
+    autoSrc.includes("Worktree lifecycle on milestone transition"),
+    "auto.ts should contain the worktree lifecycle comment marker",
+  );
+  assert.ok(
+    autoSrc.includes("mergeMilestoneToMain") && autoSrc.includes("mid !== currentMilestoneId"),
+    "auto.ts should call mergeMilestoneToMain during milestone transition",
+  );
+  assert.ok(
+    autoSrc.includes("createAutoWorktree") && autoSrc.includes("Created auto-worktree for"),
+    "auto.ts should create new worktree for incoming milestone",
+  );
+});

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

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { lookupModelCost, compareModelCost, BUNDLED_COST_TABLE } from "../model-cost-table.js";
+
+// ─── lookupModelCost ─────────────────────────────────────────────────────────
+
+test("lookupModelCost finds exact match", () => {
+  const entry = lookupModelCost("claude-opus-4-6");
+  assert.ok(entry);
+  assert.equal(entry.id, "claude-opus-4-6");
+  assert.ok(entry.inputPer1k > 0);
+  assert.ok(entry.outputPer1k > 0);
+});
+
+test("lookupModelCost strips provider prefix", () => {
+  const entry = lookupModelCost("anthropic/claude-opus-4-6");
+  assert.ok(entry);
+  assert.equal(entry.id, "claude-opus-4-6");
+});
+
+test("lookupModelCost returns undefined for unknown model", () => {
+  const entry = lookupModelCost("totally-unknown-model");
+  assert.equal(entry, undefined);
+});
+
+test("lookupModelCost finds haiku", () => {
+  const entry = lookupModelCost("claude-haiku-4-5");
+  assert.ok(entry);
+  assert.ok(entry.inputPer1k < 0.001, "haiku should be cheap");
+});
+
+// ─── compareModelCost ────────────────────────────────────────────────────────
+
+test("haiku is cheaper than opus", () => {
+  assert.ok(compareModelCost("claude-haiku-4-5", "claude-opus-4-6") < 0);
+});
+
+test("opus is more expensive than sonnet", () => {
+  assert.ok(compareModelCost("claude-opus-4-6", "claude-sonnet-4-6") > 0);
+});
+
+test("same model has equal cost", () => {
+  assert.equal(compareModelCost("claude-opus-4-6", "claude-opus-4-6"), 0);
+});
+
+// ─── BUNDLED_COST_TABLE ──────────────────────────────────────────────────────
+
+test("cost table has entries for all major providers", () => {
+  const ids = BUNDLED_COST_TABLE.map(e => e.id);
+  // Anthropic
+  assert.ok(ids.includes("claude-opus-4-6"));
+  assert.ok(ids.includes("claude-sonnet-4-6"));
+  assert.ok(ids.includes("claude-haiku-4-5"));
+  // OpenAI
+  assert.ok(ids.includes("gpt-4o"));
+  assert.ok(ids.includes("gpt-4o-mini"));
+  // Google
+  assert.ok(ids.includes("gemini-2.0-flash"));
+});
+
+test("all cost table entries have valid data", () => {
+  for (const entry of BUNDLED_COST_TABLE) {
+    assert.ok(entry.id, `entry missing id`);
+    assert.ok(entry.inputPer1k >= 0, `${entry.id} inputPer1k should be >= 0`);
+    assert.ok(entry.outputPer1k >= 0, `${entry.id} outputPer1k should be >= 0`);
+    assert.ok(entry.updatedAt, `${entry.id} missing updatedAt`);
+  }
+});

package/dist/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for model config isolation between concurrent instances (#650).
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeTmpDir(suffix: string): string {
+  const dir = join(tmpdir(), `gsd-test-650-${suffix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Settings Manager Model Scoping ───────────────────────────────────────────
+
+describe("model config isolation (#650)", () => {
+  let tmpGlobal: string;
+  let tmpProjectA: string;
+  let tmpProjectB: string;
+
+  beforeEach(() => {
+    tmpGlobal = makeTmpDir("global");
+    tmpProjectA = makeTmpDir("project-a");
+    tmpProjectB = makeTmpDir("project-b");
+    // Create .pi directories for project settings
+    mkdirSync(join(tmpProjectA, ".pi"), { recursive: true });
+    mkdirSync(join(tmpProjectB, ".pi"), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(tmpGlobal, { recursive: true, force: true }); } catch {}
+    try { rmSync(tmpProjectA, { recursive: true, force: true }); } catch {}
+    try { rmSync(tmpProjectB, { recursive: true, force: true }); } catch {}
+  });
+
+  it("project settings file isolates model from global", async () => {
+    // Write project settings for project A
+    const projectSettingsPath = join(tmpProjectA, ".pi", "settings.json");
+    writeFileSync(projectSettingsPath, JSON.stringify({
+      defaultProvider: "anthropic",
+      defaultModel: "claude-opus-4-6",
+    }));
+
+    // Write global settings with a different model
+    const globalSettingsPath = join(tmpGlobal, "settings.json");
+    writeFileSync(globalSettingsPath, JSON.stringify({
+      defaultProvider: "openai",
+      defaultModel: "gpt-5.4",
+    }));
+
+    // Verify project settings exist and have independent data
+    const projectData = JSON.parse(readFileSync(projectSettingsPath, "utf-8"));
+    const globalData = JSON.parse(readFileSync(globalSettingsPath, "utf-8"));
+
+    assert.equal(projectData.defaultModel, "claude-opus-4-6");
+    assert.equal(globalData.defaultModel, "gpt-5.4");
+    assert.notEqual(projectData.defaultModel, globalData.defaultModel,
+      "Project and global should have different models");
+  });
+
+  it("two projects have independent model configs", () => {
+    const settingsA = join(tmpProjectA, ".pi", "settings.json");
+    const settingsB = join(tmpProjectB, ".pi", "settings.json");
+
+    writeFileSync(settingsA, JSON.stringify({
+      defaultProvider: "anthropic",
+      defaultModel: "claude-opus-4-6",
+    }));
+    writeFileSync(settingsB, JSON.stringify({
+      defaultProvider: "openai-codex",
+      defaultModel: "gpt-5.4",
+    }));
+
+    const dataA = JSON.parse(readFileSync(settingsA, "utf-8"));
+    const dataB = JSON.parse(readFileSync(settingsB, "utf-8"));
+
+    assert.equal(dataA.defaultModel, "claude-opus-4-6");
+    assert.equal(dataB.defaultModel, "gpt-5.4");
+    assert.notEqual(dataA.defaultProvider, dataB.defaultProvider);
+  });
+
+  it("autoModeStartModel concept prevents model drift", () => {
+    // Simulate the auto-mode start model capture pattern
+    const autoModeStartModel = { provider: "anthropic", id: "claude-opus-4-6" };
+
+    // Simulate another instance writing to global settings
+    const globalSettings = { defaultProvider: "openai-codex", defaultModel: "gpt-5.4" };
+
+    // The captured model should be used, not the global settings
+    assert.notEqual(autoModeStartModel.id, globalSettings.defaultModel);
+    assert.equal(autoModeStartModel.id, "claude-opus-4-6",
+      "Captured model should be preserved regardless of global settings changes");
+  });
+});

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

@@ -0,0 +1,167 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveModelForComplexity,
+  escalateTier,
+  defaultRoutingConfig,
+} from "../model-router.js";
+import type { DynamicRoutingConfig, RoutingDecision } from "../model-router.js";
+import type { ClassificationResult } from "../complexity-classifier.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeClassification(tier: "light" | "standard" | "heavy", reason = "test"): ClassificationResult {
+  return { tier, reason, downgraded: false };
+}
+
+const AVAILABLE_MODELS = [
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+  "gpt-4o-mini",
+];
+
+// ─── Passthrough when disabled ───────────────────────────────────────────────
+
+test("returns configured model when routing is disabled", () => {
+  const config = { ...defaultRoutingConfig(), enabled: false };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("returns configured model when no phase config", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    undefined,
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "");
+  assert.equal(result.wasDowngraded, false);
+});
+
+// ─── Downgrade-only semantics ────────────────────────────────────────────────
+
+test("does not downgrade when tier matches configured model tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("does not upgrade beyond configured model", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Configured model is sonnet (standard), classification says heavy
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-sonnet-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-sonnet-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("downgrades from opus to haiku for light tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  // Should pick haiku or gpt-4o-mini (cheapest light tier)
+  assert.ok(
+    result.modelId === "claude-haiku-4-5" || result.modelId === "gpt-4o-mini",
+    `Expected light-tier model, got ${result.modelId}`,
+  );
+  assert.equal(result.wasDowngraded, true);
+});
+
+test("downgrades from opus to sonnet for standard tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-sonnet-4-6");
+  assert.equal(result.wasDowngraded, true);
+});
+
+// ─── Explicit tier_models ────────────────────────────────────────────────────
+
+test("uses explicit tier_models when configured", () => {
+  const config: DynamicRoutingConfig = {
+    ...defaultRoutingConfig(),
+    enabled: true,
+    tier_models: { light: "gpt-4o-mini", standard: "claude-sonnet-4-6" },
+  };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "gpt-4o-mini");
+  assert.equal(result.wasDowngraded, true);
+});
+
+// ─── Fallback chain construction ─────────────────────────────────────────────
+
+test("fallback chain includes configured primary as last resort", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: ["claude-sonnet-4-6"] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.ok(result.wasDowngraded);
+  // Fallbacks should include the configured fallbacks and primary
+  assert.ok(result.fallbacks.includes("claude-opus-4-6"), "primary should be in fallbacks");
+  assert.ok(result.fallbacks.includes("claude-sonnet-4-6"), "configured fallback should be in fallbacks");
+});
+
+// ─── Escalation ──────────────────────────────────────────────────────────────
+
+test("escalateTier moves light → standard", () => {
+  assert.equal(escalateTier("light"), "standard");
+});
+
+test("escalateTier moves standard → heavy", () => {
+  assert.equal(escalateTier("standard"), "heavy");
+});
+
+test("escalateTier returns null for heavy (max)", () => {
+  assert.equal(escalateTier("heavy"), null);
+});
+
+// ─── No suitable model available ─────────────────────────────────────────────
+
+test("falls back to configured model when no light-tier model available", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Only heavy-tier models available
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["claude-opus-4-6"],
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});

package/dist/resources/extensions/gsd/tests/parsers.test.ts

@@ -1661,4 +1661,44 @@ console.log('\n=== LLM round-trip: extra blank lines ===');
   assertTrue(consecutiveBlanks === null, 'blank-lines: formatted output has no 4+ consecutive newlines');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// parseRoadmap: boundary map with embedded code fences (#468)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== parseRoadmap: boundary map with code fences (#468) ===');
+{
+  const content = `# M001: Test
+
+**Vision:** Test
+
+## Slices
+
+- [ ] **S01: Core** \`risk:low\` \`depends:[]\`
+- [ ] **S02: API** \`risk:low\` \`depends:[S01]\`
+
+## Boundary Map
+
+### S01 → S02
+
+Produces:
+  types.ts — all types
+  \`\`\`
+  const x = 1;
+  \`\`\`
+
+Consumes: nothing
+`;
+
+  // This test ensures the boundary map parser does not hang or
+  // catastrophically backtrack when content contains code fences.
+  const start = Date.now();
+  const r = parseRoadmap(content);
+  const elapsed = Date.now() - start;
+
+  assertTrue(elapsed < 1000, `boundary map with code fences parsed in ${elapsed}ms (should be < 1s)`);
+  assertEq(r.slices.length, 2, 'code-fence roadmap: slice count');
+  // Boundary map should still parse (may not capture perfectly with code fences, but must not hang)
+  assertTrue(r.boundaryMap.length >= 0, 'code-fence roadmap: boundary map parsed without hanging');
+}
+
 report();

package/dist/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -1,5 +1,4 @@
 // GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -18,6 +17,7 @@ import {
   clearPersistedHookState,
   getHookStatus,
   formatHookStatus,
+  triggerHookManually,
 } from "../post-unit-hooks.ts";
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
@@ -294,4 +294,44 @@ console.log("\n=== Hook status: no hooks ===");
   assertMatch(formatted, /No hooks configured/, "status message says no hooks");
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 4: Manual Hook Trigger Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== triggerHookManually: hook not found ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = triggerHookManually("nonexistent-hook", "execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when hook not found");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== triggerHookManually: with configured hook ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    // This test will work when preferences are configured
+    // For now, just verify the function exists and handles missing hooks
+    const result = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
+    // Result depends on whether code-review hook is configured in preferences
+    // The function should either return null or a valid HookDispatchResult
+    assertTrue(result === null || typeof result === "object", "returns null or object");
+    if (result) {
+      assertEq(result.hookName, "code-review", "hook name in result");
+      assertEq(result.unitType, "hook/code-review", "unit type is hook-prefixed");
+      assertEq(result.unitId, "M001/S01/T01", "unit ID preserved");
+      assertTrue(typeof result.prompt === "string", "prompt is a string");
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 report();

package/dist/resources/extensions/gsd/tests/preferences-git.test.ts

@@ -1,5 +1,4 @@
 // GSD Git Preferences Tests — validates git.isolation and git.merge_to_main handling
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { createTestContext } from "./test-helpers.ts";
 import { validatePreferences } from "../preferences.ts";

package/dist/resources/extensions/gsd/tests/preferences-hooks.test.ts

@@ -1,5 +1,4 @@
 // GSD Extension — Hook Preferences Parsing Tests (Post-Unit + Pre-Dispatch)
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { createTestContext } from "./test-helpers.ts";
 import type { PreDispatchHookConfig } from "../types.ts";