gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

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

@@ -1,157 +0,0 @@
-/**
- * Tests for model config isolation between concurrent instances (#650, #1065).
- */
-
-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");
-  });
-});
-
-// ─── Session model recovery on error (#1065) ─────────────────────────────────
-
-describe("session model recovery on error (#1065)", () => {
-  it("session model is preferred over fallback chain from disk when models diverge", () => {
-    // Simulate: Session started with opus, fallback chain exhausted,
-    // another session's global prefs point to a different model.
-    const sessionModel = { provider: "anthropic", id: "claude-opus-4-6" };
-    const currentModel = { provider: "openai-codex", id: "codex-mini-latest" };
-
-    // The session model should be restored when current model differs
-    const shouldRecover = currentModel.id !== sessionModel.id
-      || currentModel.provider !== sessionModel.provider;
-
-    assert.ok(shouldRecover,
-      "Recovery should trigger when current model diverged from session model");
-  });
-
-  it("session model recovery is skipped when model has not diverged", () => {
-    // If the current model is still the session model, no recovery needed
-    const sessionModel = { provider: "anthropic", id: "claude-opus-4-6" };
-    const currentModel = { provider: "anthropic", id: "claude-opus-4-6" };
-
-    const shouldRecover = currentModel.id !== sessionModel.id
-      || currentModel.provider !== sessionModel.provider;
-
-    assert.ok(!shouldRecover,
-      "Recovery should NOT trigger when current model matches session model");
-  });
-
-  it("cross-session model leakage scenario is detected", () => {
-    // Session A: user chose opus for project-alpha
-    const sessionA = { provider: "anthropic", id: "claude-opus-4-6" };
-    // Session B: user chose gpt-5.4 for project-beta
-    const sessionB = { provider: "openai", id: "gpt-5.4" };
-
-    // If Session A's error handler somehow picked up Session B's model,
-    // the session model recovery should detect the divergence
-    const currentModelAfterBadFallback = sessionB; // leakage happened
-    const shouldRecover = currentModelAfterBadFallback.id !== sessionA.id
-      || currentModelAfterBadFallback.provider !== sessionA.provider;
-
-    assert.ok(shouldRecover,
-      "Session model recovery must detect cross-session leakage and restore original model");
-    assert.equal(sessionA.id, "claude-opus-4-6",
-      "Session A's model must be restored, not Session B's");
-  });
-
-  it("session model is null-safe when auto-mode was not started", () => {
-    // When getAutoModeStartModel() returns null, recovery should be skipped
-    const sessionModel: { provider: string; id: string } | null = null;
-
-    // The recovery block should guard against null
-    const shouldAttemptRecovery = sessionModel !== null;
-    assert.ok(!shouldAttemptRecovery,
-      "Recovery should be skipped when no session model was captured");
-  });
-});

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

@@ -1,167 +0,0 @@
-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/must-have-parser.test.ts

@@ -1,291 +0,0 @@
-import { parseTaskPlanMustHaves } from '../files.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ═══════════════════════════════════════════════════════════════════════════
-// (a) Standard unchecked format: - [ ] text
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: standard unchecked ===');
-{
-  const content = `# T01: Test Task
-
-## Must-Haves
-
-- [ ] First must-have item
-- [ ] Second must-have item
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 2, 'should return 2 items');
-  assertEq(result[0].text, 'First must-have item', 'first item text');
-  assertEq(result[0].checked, false, 'first item unchecked');
-  assertEq(result[1].text, 'Second must-have item', 'second item text');
-  assertEq(result[1].checked, false, 'second item unchecked');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (b) Checked variants: - [x] and - [X]
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: checked [x] and [X] ===');
-{
-  const content = `## Must-Haves
-
-- [x] Lowercase checked item
-- [X] Uppercase checked item
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 2, 'should return 2 items');
-  assertEq(result[0].checked, true, 'lowercase x is checked');
-  assertEq(result[0].text, 'Lowercase checked item', 'lowercase x text');
-  assertEq(result[1].checked, true, 'uppercase X is checked');
-  assertEq(result[1].text, 'Uppercase checked item', 'uppercase X text');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (c) No-checkbox bullets: - text
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: no-checkbox bullets ===');
-{
-  const content = `## Must-Haves
-
-- Plain bullet item
-- Another plain item
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 2, 'should return 2 items');
-  assertEq(result[0].text, 'Plain bullet item', 'plain bullet text');
-  assertEq(result[0].checked, false, 'plain bullet defaults to unchecked');
-  assertEq(result[1].text, 'Another plain item', 'second plain bullet text');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (d) Indented variants
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: indented variants ===');
-{
-  const content = `## Must-Haves
-
-  - [ ] Indented unchecked item
-  - [x] Indented checked item
-  - Plain indented item
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 3, 'should return 3 items');
-  assertEq(result[0].text, 'Indented unchecked item', 'indented unchecked text');
-  assertEq(result[0].checked, false, 'indented unchecked state');
-  assertEq(result[1].text, 'Indented checked item', 'indented checked text');
-  assertEq(result[1].checked, true, 'indented checked state');
-  assertEq(result[2].text, 'Plain indented item', 'indented plain text');
-  assertEq(result[2].checked, false, 'indented plain state');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (e) Mixed checkbox states in one section
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: mixed states ===');
-{
-  const content = `## Must-Haves
-
-- [ ] Unchecked one
-- [x] Checked one
-- [X] Also checked
-- Plain bullet
-- [ ] Another unchecked
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 5, 'should return 5 items');
-  assertEq(result[0].checked, false, 'first is unchecked');
-  assertEq(result[1].checked, true, 'second is checked');
-  assertEq(result[2].checked, true, 'third is checked (uppercase)');
-  assertEq(result[3].checked, false, 'fourth (plain) is unchecked');
-  assertEq(result[4].checked, false, 'fifth is unchecked');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (f) Missing Must-Haves section → empty array
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: missing section ===');
-{
-  const content = `# T01: Some Task
-
-## Description
-
-Some description here.
-
-## Verification
-
-- Run tests
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 0, 'returns empty array when section missing');
-  assertTrue(Array.isArray(result), 'result is an array');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (g) Empty Must-Haves section → empty array
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: empty section ===');
-{
-  const content = `## Must-Haves
-
-## Verification
-
-- Run tests
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 0, 'returns empty array when section is empty');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (h) Content with YAML frontmatter
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: YAML frontmatter ===');
-{
-  const content = `---
-estimated_steps: 5
-estimated_files: 3
----
-
-# T01: Task with frontmatter
-
-## Must-Haves
-
-- [ ] Real must-have after frontmatter
-- [x] Checked must-have after frontmatter
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 2, 'frontmatter does not pollute results');
-  assertEq(result[0].text, 'Real must-have after frontmatter', 'first item text correct');
-  assertEq(result[0].checked, false, 'first item unchecked');
-  assertEq(result[1].text, 'Checked must-have after frontmatter', 'second item text correct');
-  assertEq(result[1].checked, true, 'second item checked');
-}
-
-// Verify frontmatter content is not misinterpreted as must-haves
-console.log('\n=== parseTaskPlanMustHaves: frontmatter-only content ===');
-{
-  const content = `---
-estimated_steps: 5
-estimated_files: 3
----
-
-# T01: Task with only frontmatter
-
-## Description
-
-No must-haves section here.
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 0, 'frontmatter-only content returns empty array');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// (i) Real task plan format (based on S01/T01-PLAN.md structure)
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: real task plan format ===');
-{
-  const content = `---
-estimated_steps: 5
-estimated_files: 3
----
-
-# T01: Add completing-milestone phase to deriveState with tests
-
-**Slice:** S01 — Milestone Completion Unit
-**Milestone:** M002
-
-## Description
-
-Add the \`completing-milestone\` phase to the GSD state machine.
-
-## Steps
-
-1. Add \`'completing-milestone'\` to the \`Phase\` union type in \`types.ts\`.
-2. In \`state.ts\`, modify the registry-building loop.
-
-## Must-Haves
-
-- [ ] \`Phase\` type includes \`'completing-milestone'\`
-- [ ] \`deriveState\` returns \`phase: 'completing-milestone'\` when all slices are \`[x]\` and no \`M00x-SUMMARY.md\` exists
-- [ ] \`deriveState\` returns milestone as \`'complete'\` and advances when summary exists
-- [ ] All 63+ existing \`deriveState\` tests pass without modification
-- [ ] New test fixtures cover single-milestone and multi-milestone completing-milestone scenarios
-
-## Verification
-
-- Run tests
-- All existing 63 assertions pass
-
-## Observability Impact
-
-- Signals added/changed: \`completing-milestone\` phase now visible
-- How a future agent inspects this: Run \`deriveState(basePath)\`
-- Failure state exposed: If \`deriveState\` doesn't detect the phase
-
-## Inputs
-
-- \`agent/extensions/gsd/types.ts\` — Phase type definition
-
-## Expected Output
-
-- \`agent/extensions/gsd/types.ts\` — Phase union includes \`'completing-milestone'\`
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 5, 'real plan has 5 must-haves');
-  assertTrue(result[0].text.includes('`Phase` type includes'), 'first must-have text matches');
-  assertTrue(result[1].text.includes('`deriveState` returns'), 'second must-have text matches');
-  assertEq(result[0].checked, false, 'all real must-haves are unchecked');
-  assertEq(result[4].checked, false, 'last real must-have is unchecked');
-  assertTrue(result[4].text.includes('multi-milestone'), 'last must-have references multi-milestone');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Edge cases
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== parseTaskPlanMustHaves: empty string ===');
-{
-  const result = parseTaskPlanMustHaves('');
-  assertEq(result.length, 0, 'empty string returns empty array');
-}
-
-console.log('\n=== parseTaskPlanMustHaves: must-haves with inline code and backticks ===');
-{
-  const content = `## Must-Haves
-
-- [ ] \`functionName\` is exported from \`module.ts\`
-- [x] Returns \`Array<{ text: string }>\` with correct extraction
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 2, 'handles backtick content');
-  assertTrue(result[0].text.includes('`functionName`'), 'preserves backticks in text');
-  assertEq(result[0].checked, false, 'backtick item unchecked');
-  assertEq(result[1].checked, true, 'backtick item checked');
-}
-
-console.log('\n=== parseTaskPlanMustHaves: asterisk bullets ===');
-{
-  const content = `## Must-Haves
-
-* [ ] Asterisk unchecked
-* [x] Asterisk checked
-* Plain asterisk
-`;
-  const result = parseTaskPlanMustHaves(content);
-  assertEq(result.length, 3, 'handles asterisk bullets');
-  assertEq(result[0].checked, false, 'asterisk unchecked');
-  assertEq(result[1].checked, true, 'asterisk checked');
-  assertEq(result[2].checked, false, 'plain asterisk unchecked');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-
-report();