gsd-pi 2.37.0 → 2.37.1-dev.3bbb0a9

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

@@ -14,6 +14,7 @@ import {
   type AgentEndEvent,
   type LoopDeps,
 } from "../auto-loop.js";
+import type { SessionLockStatus } from "../session-lock.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -341,7 +342,7 @@ function makeMockDeps(
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
     syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
-    validateSessionLock: () => true,
+    validateSessionLock: () => ({ valid: true } as SessionLockStatus),
     updateSessionLock: () => {
       callLog.push("updateSessionLock");
     },
@@ -532,6 +533,41 @@ test("autoLoop exits on terminal complete state", async (t) => {
   );
 });
 
+test("autoLoop passes structured session-lock failure details to the handler", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  let observedLockStatus: SessionLockStatus | undefined;
+
+  const deps = makeMockDeps({
+    validateSessionLock: () =>
+      ({
+        valid: false,
+        failureReason: "compromised",
+        expectedPid: process.pid,
+      }) as SessionLockStatus,
+    handleLostSessionLock: (_ctx, lockStatus) => {
+      observedLockStatus = lockStatus;
+      deps.callLog.push("handleLostSessionLock");
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.deepEqual(observedLockStatus, {
+    valid: false,
+    failureReason: "compromised",
+    expectedPid: process.pid,
+  });
+  assert.ok(
+    !deps.callLog.includes("resolveDispatch"),
+    "should stop before dispatch after lock validation fails",
+  );
+});
+
 test("autoLoop exits on terminal blocked state", async (t) => {
   _resetPendingResolve();
 

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

@@ -153,6 +153,25 @@ async function main(): Promise<void> {
     // After teardown, originalBase should be null
     assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
+    // ─── #1526: getMainBranch returns milestone branch in auto-worktree ──
+    console.log("\n=== #1526: getMainBranch() returns milestone/<MID> in auto-worktree ===");
+    {
+      const { GitServiceImpl } = await import("../git-service.ts");
+
+      // Create worktree
+      const wtPath = createAutoWorktree(tempDir, "M005");
+      // Don't set main_branch pref so getMainBranch falls through to worktree detection
+      const gitService = new GitServiceImpl(wtPath);
+      gitService.setMilestoneId("M005");
+
+      // Verify getMainBranch returns the milestone branch
+      const mainBranch = gitService.getMainBranch();
+      assertEq(mainBranch, "milestone/M005", "getMainBranch returns milestone/<MID> in auto-worktree");
+
+      // Cleanup
+      teardownAutoWorktree(tempDir, "M005");
+    }
+
     // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
     console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
     {

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

@@ -1,5 +1,8 @@
-import test from "node:test";
+import test, { describe } from "node:test";
 import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   buildCmuxProgress,
   buildCmuxStatusLabel,
@@ -96,3 +99,24 @@ test("buildCmuxStatusLabel and progress prefer deepest active unit", () => {
   assert.equal(buildCmuxStatusLabel(state), "M001 S02/T03 · executing");
   assert.deepEqual(buildCmuxProgress(state), { value: 0.4, label: "2/5 tasks" });
 });
+
+describe("cmux extension discovery opt-out", () => {
+  test("cmux directory has package.json with pi manifest to prevent auto-discovery as extension", () => {
+    const cmuxDir = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "../../cmux",
+    );
+    const pkgPath = path.join(cmuxDir, "package.json");
+    assert.ok(fs.existsSync(pkgPath), `${pkgPath} must exist`);
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    assert.ok(
+      pkg.pi !== undefined && typeof pkg.pi === "object",
+      'package.json must have a "pi" field to opt out of extension auto-discovery',
+    );
+    assert.ok(
+      !pkg.pi.extensions?.length,
+      "pi.extensions must be empty or absent — cmux is a library, not an extension",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -184,7 +184,7 @@ test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", (
   // Isolate from real HOME so loadEffectiveGSDPreferences returns null (default → anthropic)
   // and auth.json lookups hit an empty directory.
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-env-test-")));
-  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", HOME: tmpHome }, () => {
+  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", ANTHROPIC_OAUTH_TOKEN: undefined, HOME: tmpHome }, () => {
     try {
       const results = runProviderChecks();
       const anthropic = results.find(r => r.name === "anthropic");
@@ -199,7 +199,15 @@ test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", (
 
 test("runProviderChecks returns error for Anthropic when no key present", () => {
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
-  withEnv({ ANTHROPIC_API_KEY: undefined, HOME: tmpHome }, () => {
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    // Clear cross-provider routing env vars (GitHub Copilot can serve Claude models)
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
     try {
       const results = runProviderChecks();
       const anthropic = results.find(r => r.name === "anthropic");
@@ -275,7 +283,7 @@ test("runProviderChecks detects key from auth.json", () => {
 });
 
 test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
-  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined, ANTHROPIC_OAUTH_TOKEN: undefined, COPILOT_GITHUB_TOKEN: undefined, GH_TOKEN: undefined, GITHUB_TOKEN: undefined }, () => {
     const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
     const agentDir = join(tmpHome, ".gsd", "agent");
     mkdirSync(agentDir, { recursive: true });
@@ -296,3 +304,100 @@ test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
     rmSync(tmpHome, { recursive: true, force: true });
   });
 });
+
+// ─── runProviderChecks — cross-provider routing ──────────────────────────────
+
+test("runProviderChecks reports ok for Anthropic when GitHub Copilot env var is set", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-copilot-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: "ghu_copilot-token",
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when Copilot auth is available");
+      assert.ok(anthropic!.message.includes("GitHub Copilot"), "should mention cross-provider source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks reports ok for Anthropic via GITHUB_TOKEN cross-provider routing", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-ghtoken-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: "ghp_github-token",
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when GITHUB_TOKEN provides Copilot access");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks detects ANTHROPIC_OAUTH_TOKEN as valid Anthropic auth", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-oauth-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: "oauth-token-test",
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when ANTHROPIC_OAUTH_TOKEN is set");
+      assert.ok(anthropic!.message.includes("env"), "should report env source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks reports ok via Copilot auth.json for Anthropic", () => {
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+  }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-copilot-auth-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // GitHub Copilot OAuth in auth.json
+    const authData = {
+      "github-copilot": { type: "oauth", apiKey: "ghu_copilot-key", expires: Date.now() + 3_600_000 },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when Copilot is authenticated in auth.json");
+      assert.ok(anthropic!.message.includes("GitHub Copilot"), "should mention Copilot as source");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});

package/src/resources/extensions/gsd/tests/plan-quality-validator.test.ts

@@ -360,4 +360,115 @@ console.log('\n=== Clean slice plan: no plan-quality issues ===');
   assertEq(planQualityIssues.length, 0, 'clean slice plan produces no empty_task_entry issues');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — missing output file paths
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: missing output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+This task produces the main output.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Expected Output without file paths triggers missing_output_file_paths');
+}
+
+console.log('\n=== validateTaskPlanContent: valid output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+- \`src/types.ts\` — New type definitions
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertEq(outputIssues.length, 0, 'Expected Output with file paths does not trigger warning');
+}
+
+console.log('\n=== validateTaskPlanContent: missing input file paths (info severity) ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Inputs
+
+Prior task summary insights about the architecture.
+
+## Expected Output
+
+- \`src/output.ts\` — Output file
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const inputIssues = issues.filter(i => i.ruleId === 'missing_input_file_paths');
+  assertTrue(inputIssues.length >= 1, 'Inputs without file paths triggers missing_input_file_paths');
+  if (inputIssues.length > 0) {
+    assertEq(inputIssues[0].severity, 'info', 'missing_input_file_paths is info severity (not warning)');
+  }
+}
+
+console.log('\n=== validateTaskPlanContent: no Expected Output section at all ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Missing Expected Output section triggers missing_output_file_paths');
+}
+
 report();