gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.2ccf3fb

package/dist/resources/extensions/gsd/tests/extension-selector-separator.test.ts

@@ -1,4 +1,6 @@
-// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent.
+// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent
+// and the two-step provider→model picker in configureModels.
+//
 // We cannot import the component directly in node:test because its transitive
 // dependency (countdown-timer.ts) uses TypeScript parameter properties which
 // are unsupported under --experimental-strip-types. Instead we duplicate the
@@ -69,16 +71,17 @@ describe("separator detection", () => {
 	});
 });
 
-describe("model grouping", () => {
-	test("groups models by provider with separator headers", () => {
-		// Simulate the grouping logic from configureModels
-		const availableModels = [
-			{ id: "claude-opus-4-6", provider: "anthropic" },
-			{ id: "gpt-4o", provider: "openai" },
-			{ id: "claude-sonnet-4-5", provider: "anthropic" },
-			{ id: "o3-mini", provider: "openai" },
-		];
+describe("two-step provider→model picker", () => {
+	// Simulate the grouping logic from configureModels
+	const availableModels = [
+		{ id: "claude-opus-4-6", provider: "anthropic" },
+		{ id: "gpt-4o", provider: "openai" },
+		{ id: "claude-sonnet-4-5", provider: "anthropic" },
+		{ id: "o3-mini", provider: "openai" },
+		{ id: "claude-haiku-4-5", provider: "anthropic" },
+	];
 
+	function buildProviderGroups() {
 		const byProvider = new Map<string, typeof availableModels>();
 		for (const m of availableModels) {
 			let group = byProvider.get(m.provider);
@@ -89,34 +92,53 @@ describe("model grouping", () => {
 			group.push(m);
 		}
 		const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-
-		const modelOptions: string[] = [];
-		for (const provider of providers) {
-			const group = byProvider.get(provider)!;
-			modelOptions.push(`${SEPARATOR_PREFIX} ${provider} (${group.length}) ${SEPARATOR_PREFIX}`);
-			for (const m of group) {
-				modelOptions.push(`${m.id} · ${m.provider}`);
-			}
+		for (const group of byProvider.values()) {
+			group.sort((a, b) => a.id.localeCompare(b.id));
 		}
-		modelOptions.push("(keep current)", "(clear)");
-
-		// Verify structure
-		assert.strictEqual(modelOptions[0], `${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[1], "claude-opus-4-6 · anthropic");
-		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5 · anthropic");
-		assert.strictEqual(modelOptions[3], `${SEPARATOR_PREFIX} openai (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[4], "gpt-4o · openai");
-		assert.strictEqual(modelOptions[5], "o3-mini · openai");
-		assert.strictEqual(modelOptions[6], "(keep current)");
-		assert.strictEqual(modelOptions[7], "(clear)");
-
-		// Verify separators are correctly detected
-		assert.ok(isSeparator(modelOptions, 0));
-		assert.ok(!isSeparator(modelOptions, 1));
-		assert.ok(isSeparator(modelOptions, 3));
-		assert.ok(!isSeparator(modelOptions, 6));
-
-		// Verify first selectable is index 1, not the separator at 0
-		assert.strictEqual(nextSelectable(modelOptions, 0, 1), 1);
+		return { byProvider, providers };
+	}
+
+	test("provider menu lists providers with model counts", () => {
+		const { providers, byProvider } = buildProviderGroups();
+		const providerOptions = providers.map(p => {
+			const count = byProvider.get(p)!.length;
+			return `${p} (${count} models)`;
+		});
+		providerOptions.push("(keep current)", "(clear)", "(type manually)");
+
+		assert.strictEqual(providerOptions[0], "anthropic (3 models)");
+		assert.strictEqual(providerOptions[1], "openai (2 models)");
+		assert.strictEqual(providerOptions[2], "(keep current)");
+		assert.strictEqual(providerOptions[3], "(clear)");
+		assert.strictEqual(providerOptions[4], "(type manually)");
+	});
+
+	test("model menu for a provider is sorted alphabetically", () => {
+		const { byProvider } = buildProviderGroups();
+		const anthropicModels = byProvider.get("anthropic")!;
+		const modelOptions = anthropicModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "claude-haiku-4-5");
+		assert.strictEqual(modelOptions[1], "claude-opus-4-6");
+		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5");
+	});
+
+	test("provider name is extracted correctly from choice string", () => {
+		const choice = "anthropic (3 models)";
+		const providerName = choice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(providerName, "anthropic");
+
+		const singleChoice = "ollama (1 model)";
+		const singleProvider = singleChoice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(singleProvider, "ollama");
+	});
+
+	test("openai models are sorted within their group", () => {
+		const { byProvider } = buildProviderGroups();
+		const openaiModels = byProvider.get("openai")!;
+		const modelOptions = openaiModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "gpt-4o");
+		assert.strictEqual(modelOptions[1], "o3-mini");
 	});
 });

package/dist/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -3,7 +3,7 @@
 // Tests the pure formatInspectOutput function with known data.
 
 import { createTestContext } from './test-helpers.ts';
-import { formatInspectOutput, type InspectData } from '../commands.ts';
+import { formatInspectOutput, type InspectData } from '../commands-inspect.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 

package/dist/resources/extensions/gsd/tests/parallel-workers-multi-milestone-e2e.test.ts

@@ -30,7 +30,7 @@ import {
   getBudgetAlertLevel,
   getNewBudgetAlertLevel,
   getBudgetEnforcementAction,
-} from '../auto.ts';
+} from '../auto-budget.ts';
 import {
   type UnitMetrics,
   type MetricsLedger,

package/dist/resources/extensions/gsd/tests/session-lock.test.ts

@@ -0,0 +1,315 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  acquireSessionLock,
+  releaseSessionLock,
+  updateSessionLock,
+  validateSessionLock,
+  readSessionLockData,
+  isSessionLockHeld,
+  isSessionLockProcessAlive,
+} from "../session-lock.ts";
+
+// ─── acquireSessionLock ──────────────────────────────────────────────────
+
+test("acquireSessionLock succeeds on empty directory", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should acquire lock on empty dir");
+
+  // Verify lock file was created with correct data
+  const lockPath = join(dir, ".gsd", "auto.lock");
+  assert.ok(existsSync(lockPath), "auto.lock should exist after acquire");
+
+  const data = JSON.parse(readFileSync(lockPath, "utf-8"));
+  assert.equal(data.pid, process.pid, "lock should contain current PID");
+  assert.equal(data.unitType, "starting", "initial unit type should be 'starting'");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock rejects when another live process holds lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Simulate another process holding the lock by writing a lock with parent PID
+  const fakeLockData = {
+    pid: process.ppid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 2,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(fakeLockData, null, 2));
+
+  // First acquire to set up proper-lockfile state
+  const result1 = acquireSessionLock(dir);
+
+  // If proper-lockfile is available, it should manage the OS lock.
+  // If not (fallback mode), the PID check should detect the live process.
+  // Either way, we can't fully simulate another process holding an OS lock
+  // from within the same process, so we test the fallback path.
+  if (result1.acquired) {
+    // We got the lock (proper-lockfile saw no OS lock from another process)
+    // This is expected since we're in the same process
+    releaseSessionLock(dir);
+  }
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock takes over stale lock from dead process", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Write a lock from a dead process
+  const staleLockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: "2026-03-01T00:00:00Z",
+    completedUnits: 0,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(staleLockData, null, 2));
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should take over lock from dead process");
+
+  // Verify our PID is now in the lock
+  const data = readSessionLockData(dir);
+  assert.ok(data, "lock data should exist after acquire");
+  assert.equal(data!.pid, process.pid, "lock should contain our PID now");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── releaseSessionLock ─────────────────────────────────────────────────
+
+test("releaseSessionLock removes the lock file", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  releaseSessionLock(dir);
+
+  const lockPath = join(dir, ".gsd", "auto.lock");
+  assert.ok(!existsSync(lockPath), "auto.lock should be removed after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("releaseSessionLock is safe when no lock exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Should not throw
+  releaseSessionLock(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── updateSessionLock ──────────────────────────────────────────────────
+
+test("updateSessionLock updates the lock data without re-acquiring", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  updateSessionLock(dir, "execute-task", "M001/S01/T02", 3, "/tmp/session.jsonl");
+
+  const data = readSessionLockData(dir);
+  assert.ok(data, "lock data should exist after update");
+  assert.equal(data!.pid, process.pid, "PID should still be ours");
+  assert.equal(data!.unitType, "execute-task", "unit type should be updated");
+  assert.equal(data!.unitId, "M001/S01/T02", "unit ID should be updated");
+  assert.equal(data!.completedUnits, 3, "completed count should be updated");
+  assert.equal(data!.sessionFile, "/tmp/session.jsonl", "session file should be recorded");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── validateSessionLock ────────────────────────────────────────────────
+
+test("validateSessionLock returns true when we hold the lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  assert.equal(validateSessionLock(dir), true, "should validate when we hold the lock");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("validateSessionLock returns false after release", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+  assert.equal(validateSessionLock(dir), true, "should be valid while held");
+
+  // Release the lock — both OS lock and lock file are removed
+  releaseSessionLock(dir);
+
+  // After release, _lockedPath is cleared and lock file is gone
+  assert.equal(isSessionLockHeld(dir), false, "should not be held after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("validateSessionLock returns false when another PID owns the lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Write lock data with a different PID (parent process)
+  const foreignLockData = {
+    pid: process.ppid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(foreignLockData, null, 2));
+
+  // Without holding the OS lock, validate should check PID
+  assert.equal(validateSessionLock(dir), false, "should fail when another PID owns lock");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── isSessionLockHeld ──────────────────────────────────────────────────
+
+test("isSessionLockHeld returns true after acquire", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  acquireSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), true);
+
+  releaseSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), false, "should return false after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── isSessionLockProcessAlive ──────────────────────────────────────────
+
+test("isSessionLockProcessAlive returns false for dead PID", () => {
+  const data = {
+    pid: 9999999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  assert.equal(isSessionLockProcessAlive(data), false);
+});
+
+test("isSessionLockProcessAlive returns false for own PID (recycled)", () => {
+  const data = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  // Own PID returns false because it means the lock is from a recycled PID
+  assert.equal(isSessionLockProcessAlive(data), false);
+});
+
+// ─── readSessionLockData ────────────────────────────────────────────────
+
+test("readSessionLockData returns null when no lock exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const data = readSessionLockData(dir);
+  assert.equal(data, null);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("readSessionLockData reads existing lock data", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const lockData = {
+    pid: 12345,
+    startedAt: "2026-03-18T00:00:00Z",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: "2026-03-18T00:01:00Z",
+    completedUnits: 2,
+    sessionFile: "/tmp/session.jsonl",
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const data = readSessionLockData(dir);
+  assert.ok(data, "should read lock data");
+  assert.equal(data!.pid, 12345);
+  assert.equal(data!.unitType, "execute-task");
+  assert.equal(data!.unitId, "M001/S01/T01");
+  assert.equal(data!.completedUnits, 2);
+  assert.equal(data!.sessionFile, "/tmp/session.jsonl");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── Acquire → Release → Re-Acquire lifecycle ──────────────────────────
+
+test("session lock supports acquire → release → re-acquire cycle", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // First acquire
+  const r1 = acquireSessionLock(dir);
+  assert.equal(r1.acquired, true, "first acquire should succeed");
+  assert.equal(isSessionLockHeld(dir), true);
+
+  // Release
+  releaseSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), false);
+
+  // Re-acquire
+  const r2 = acquireSessionLock(dir);
+  assert.equal(r2.acquired, true, "re-acquire after release should succeed");
+  assert.equal(isSessionLockHeld(dir), true);
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── Lock creates .gsd/ directory if needed ─────────────────────────────
+
+test("acquireSessionLock creates .gsd/ if it does not exist", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  // Do NOT create .gsd/ — let the lock function do it
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should succeed even without .gsd/");
+  assert.ok(existsSync(join(dir, ".gsd")), ".gsd/ should be created");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});

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

@@ -290,6 +290,61 @@ test("verifyExpectedArtifact fails when VALIDATION.md is missing", () => {
   }
 });
 
+test("verifyExpectedArtifact rejects VALIDATION with missing frontmatter", () => {
+  const base = makeTmpBase();
+  try {
+    // A VALIDATION file without frontmatter should be treated as incomplete —
+    // matching what deriveState expects. Without this, the artifact check passes
+    // but deriveState still returns validating-milestone, causing the hard skip loop.
+    writeValidation(base, "M001", "# Validation\nNo frontmatter here.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without frontmatter should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with missing verdict field", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without verdict field should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with unrecognized verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: unknown-value\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION with unrecognized verdict should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact passes VALIDATION with needs-attention verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds attention.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, true, "VALIDATION with needs-attention verdict should pass verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
 
 test("diagnoseExpectedArtifact returns validation path for validate-milestone", () => {