gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -0,0 +1,127 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  supportsServiceTier,
+  formatServiceTierStatus,
+  formatServiceTierFooterStatus,
+  resolveServiceTierIcon,
+} from "../service-tier.ts";
+
+// ─── supportsServiceTier ─────────────────────────────────────────────────────
+
+describe("supportsServiceTier", () => {
+  test("returns true for gpt-5.4", () => {
+    assert.equal(supportsServiceTier("gpt-5.4"), true);
+  });
+
+  test("returns true for gpt-5.4-pro", () => {
+    assert.equal(supportsServiceTier("gpt-5.4-pro"), true);
+  });
+
+  test("returns true for gpt-5.4-mini", () => {
+    assert.equal(supportsServiceTier("gpt-5.4-mini"), true);
+  });
+
+  test("returns true for openai/gpt-5.4 (provider-prefixed)", () => {
+    assert.equal(supportsServiceTier("openai/gpt-5.4"), true);
+  });
+
+  test("returns true for vibeproxy-openai/gpt-5.4 (proxy provider-prefixed)", () => {
+    assert.equal(supportsServiceTier("vibeproxy-openai/gpt-5.4"), true);
+  });
+
+  test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {
+    assert.equal(supportsServiceTier("vibeproxy-openai"), false);
+  });
+
+  test("returns false for claude-opus-4-6", () => {
+    assert.equal(supportsServiceTier("claude-opus-4-6"), false);
+  });
+
+  test("returns false for gemini-2.5-pro", () => {
+    assert.equal(supportsServiceTier("gemini-2.5-pro"), false);
+  });
+
+  test("returns false for gpt-4o", () => {
+    assert.equal(supportsServiceTier("gpt-4o"), false);
+  });
+
+  test("returns false for empty string", () => {
+    assert.equal(supportsServiceTier(""), false);
+  });
+});
+
+// ─── formatServiceTierStatus ─────────────────────────────────────────────────
+
+describe("formatServiceTierStatus", () => {
+  test("shows disabled when service_tier is undefined", () => {
+    const output = formatServiceTierStatus(undefined);
+    assert.ok(output.includes("disabled"), `Expected 'disabled' in: ${output}`);
+  });
+
+  test("mentions provider-agnostic model gating", () => {
+    const output = formatServiceTierStatus("priority");
+    assert.ok(output.includes("regardless of provider"), `Expected provider note in: ${output}`);
+  });
+
+  test("shows priority when set to priority", () => {
+    const output = formatServiceTierStatus("priority");
+    assert.ok(output.includes("priority"), `Expected 'priority' in: ${output}`);
+  });
+
+  test("shows flex when set to flex", () => {
+    const output = formatServiceTierStatus("flex");
+    assert.ok(output.includes("flex"), `Expected 'flex' in: ${output}`);
+  });
+});
+
+// ─── formatServiceTierFooterStatus ───────────────────────────────────────────
+
+describe("formatServiceTierFooterStatus", () => {
+  test("returns priority footer status for supported model", () => {
+    assert.equal(formatServiceTierFooterStatus("priority", "vibeproxy-openai/gpt-5.4"), "fast: ⚡ priority");
+  });
+
+  test("returns undefined for unsupported model", () => {
+    assert.equal(formatServiceTierFooterStatus("priority", "claude-opus-4-6"), undefined);
+  });
+
+  test("returns undefined when tier is disabled", () => {
+    assert.equal(formatServiceTierFooterStatus(undefined, "gpt-5.4"), undefined);
+  });
+});
+
+// ─── resolveServiceTierIcon ──────────────────────────────────────────────────
+
+describe("resolveServiceTierIcon", () => {
+  test("returns lightning bolt for priority tier on supported model", () => {
+    const icon = resolveServiceTierIcon("priority", "gpt-5.4");
+    assert.equal(icon, "⚡");
+  });
+
+  test("returns money icon for flex tier on supported model", () => {
+    const icon = resolveServiceTierIcon("flex", "gpt-5.4");
+    assert.equal(icon, "💰");
+  });
+
+  test("returns empty string when tier is set but model does not support it", () => {
+    const icon = resolveServiceTierIcon("priority", "claude-opus-4-6");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when tier is undefined", () => {
+    const icon = resolveServiceTierIcon(undefined, "gpt-5.4");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when both tier and model are unsupported", () => {
+    const icon = resolveServiceTierIcon(undefined, "claude-opus-4-6");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when model is empty", () => {
+    const icon = resolveServiceTierIcon("priority", "");
+    assert.equal(icon, "");
+  });
+});

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -39,7 +39,7 @@ function buildBlock(
   });
 }
 
-test("buildSkillActivationBlock matches installed skills from task context", () => {
+test("buildSkillActivationBlock does not auto-activate skills via broad context heuristic", () => {
   const base = makeTempBase();
   try {
     writeSkill(base, "react", "Use for React components, hooks, JSX, and frontend UI work.");
@@ -52,7 +52,29 @@ test("buildSkillActivationBlock matches installed skills from task context", ()
       taskTitle: "Implement React settings panel",
     });
 
-    assert.match(result, /<skill_activation>/);
+    // Skills should not be activated just because their name appears in task context.
+    // Activation requires explicit preference sources (always_use, skill_rules, prefer_skills, skills_used).
+    assert.equal(result, "");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock activates skills via prefer_skills when context matches", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "react", "Use for React components, hooks, JSX, and frontend UI work.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views, iOS layout, and Apple platform UI work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      sliceTitle: "Build React dashboard",
+      taskId: "T01",
+      taskTitle: "Implement React settings panel",
+    }, {
+      prefer_skills: ["react"],
+    });
+
     assert.match(result, /Call Skill\('react'\)/);
     assert.doesNotMatch(result, /swiftui/);
   } finally {
@@ -105,7 +127,7 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
   }
 });
 
-test("buildSkillActivationBlock honors avoid_skills", () => {
+test("buildSkillActivationBlock honors avoid_skills against always_use_skills", () => {
   const base = makeTempBase();
   try {
     writeSkill(base, "react", "Use for React components and frontend UI work.");
@@ -114,6 +136,7 @@ test("buildSkillActivationBlock honors avoid_skills", () => {
     const result = buildBlock(base, {
       taskTitle: "Implement React settings panel",
     }, {
+      always_use_skills: ["react"],
       avoid_skills: ["react"],
     });
 
@@ -138,3 +161,33 @@ test("buildSkillActivationBlock falls back cleanly when nothing matches", () =>
     cleanup(base);
   }
 });
+
+test("buildSkillActivationBlock does not activate skills from extraContext or taskPlanContent body", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "xcode-build", "Use for Xcode build workflows and iOS compilation.");
+    writeSkill(base, "ableton-lom", "Use for Ableton Live Object Model scripting.");
+    writeSkill(base, "frontend-design", "Use for frontend design systems and UI components.");
+    loadOnlyTestSkills(base);
+
+    const taskPlan = [
+      "---",
+      "skills_used: []",
+      "---",
+      "# T01: Build the API endpoint",
+      "Use xcode-build patterns and frontend-design tokens.",
+    ].join("\n");
+
+    const result = buildBlock(base, {
+      taskTitle: "Build REST API",
+      extraContext: ["Build workflow for iOS and Ableton integration testing"],
+      taskPlanContent: taskPlan,
+    });
+
+    // None of these skills should activate — extraContext and taskPlanContent body
+    // must not be used for heuristic matching.
+    assert.equal(result, "");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/skill-lifecycle.test.ts

@@ -3,7 +3,7 @@
  * Tests the pure functions — no file I/O, no extension context.
  */
 
-import { describe, it, beforeEach } from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import type { UnitMetrics } from "../metrics.js";
 
@@ -72,7 +72,7 @@ describe("skill-health", () => {
 
     // With no metrics file, should return empty
     const result = computeStaleAvoidList("/nonexistent/path", ["some-skill"]);
-    assert.ok(Array.isArray(result));
+    assert.deepEqual(result, []);
   });
 });
 

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Regression test for #1855: Stalled tool detection crashes with
+ * "The path argument must be of type string. Received undefined"
+ *
+ * When a tool stalls in-flight for 10+ minutes, the idle watchdog fires
+ * recoverTimedOutUnit(). In auto/phases.ts, buildRecoveryContext was
+ * returning an empty object `{}`, so basePath was undefined. The recovery
+ * code passed undefined to readUnitRuntimeRecord → runtimePath → join(),
+ * which throws a TypeError. The session is permanently frozen because the
+ * error propagates into the idle watchdog catch handler but the unit
+ * promise is never resolved.
+ *
+ * This test calls recoverTimedOutUnit with an empty RecoveryContext (the
+ * bug) and verifies it crashes, then calls it with a valid RecoveryContext
+ * (the fix) and verifies it does not crash.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertTrue, report } = createTestContext();
+
+// Minimal mock for ExtensionContext — only the fields recoverTimedOutUnit touches.
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: () => {},
+    },
+  } as any;
+}
+
+// Minimal mock for ExtensionAPI — only sendMessage is called during recovery.
+function makeMockPi() {
+  return {
+    sendMessage: () => {},
+  } as any;
+}
+
+// ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
+
+{
+  console.log("\n=== #1855: recoverTimedOutUnit crashes when basePath is undefined ===");
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+
+  // Simulate the bug: buildRecoveryContext returns {} (empty object).
+  // basePath is undefined, which causes join(undefined, ".gsd") to throw.
+  const emptyRctx = {} as RecoveryContext;
+
+  let crashed = false;
+  try {
+    await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", emptyRctx);
+  } catch (err: any) {
+    crashed = true;
+    assertTrue(
+      err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
+      `should crash with path/type error, got: ${err.message}`,
+    );
+  }
+  assertTrue(crashed, "should crash when basePath is undefined (reproduces #1855)");
+}
+
+// ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
+
+{
+  console.log("\n=== #1855: recoverTimedOutUnit succeeds with valid RecoveryContext ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-stalled-tool-test-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "runtime", "units"), { recursive: true });
+
+  try {
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+
+    const validRctx: RecoveryContext = {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    };
+
+    let crashed = false;
+    let result: string | undefined;
+    try {
+      result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", validRctx);
+    } catch (err: any) {
+      crashed = true;
+      console.error(`  Unexpected crash: ${err.message}`);
+    }
+    assertTrue(!crashed, "should not crash with valid basePath");
+    // With no runtime record on disk and recoveryAttempts=0, the function
+    // should attempt steering recovery (sendMessage) and return "recovered".
+    assertTrue(result === "recovered", `should return 'recovered', got '${result}'`);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+report();

package/src/resources/extensions/gsd/tests/structured-data-formatter.test.ts

@@ -86,16 +86,17 @@ describe("structured-data-formatter: formatDecisionCompact", () => {
     const result = formatDecisionCompact(sampleDecision);
     assert.equal(
       result,
-      "D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode, single-writer | Built-in, no external deps | yes",
+      "D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode, single-writer | Built-in, no external deps | yes | agent",
     );
   });
 
   it("includes all fields in the correct order", () => {
     const result = formatDecisionCompact(sampleDecision);
     const parts = result.split(" | ");
-    assert.equal(parts.length, 7);
+    assert.equal(parts.length, 8);
     assert.equal(parts[0], "D001");
     assert.equal(parts[6], "yes");
+    assert.equal(parts[7], "agent");
   });
 });
 
@@ -107,7 +108,7 @@ describe("structured-data-formatter: formatDecisionsCompact", () => {
   it("includes Fields header line", () => {
     const result = formatDecisionsCompact([sampleDecision]);
     assert.ok(result.startsWith("# Decisions (compact)"));
-    assert.ok(result.includes("Fields: id | when | scope | decision | choice | rationale | revisable"));
+    assert.ok(result.includes("Fields: id | when | scope | decision | choice | rationale | revisable | made_by"));
   });
 
   it("formats multiple decisions on separate lines", () => {

package/src/resources/extensions/gsd/tests/symlink-numbered-variants.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for macOS numbered symlink variant cleanup (#2205).
+ *
+ * macOS can rename `.gsd` to `.gsd 2`, `.gsd 3`, etc. when a directory
+ * already exists at the target path. ensureGsdSymlink() must detect and
+ * remove these numbered variants so the real `.gsd` symlink is always
+ * the one in use.
+ */
+
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  lstatSync,
+  realpathSync,
+  mkdirSync,
+  symlinkSync,
+  readlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { ensureGsdSymlink, externalGsdRoot } from "../repo-identity.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+async function main(): Promise<void> {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-symlink-variants-")));
+  const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-variants-")));
+
+  try {
+    process.env.GSD_STATE_DIR = stateDir;
+
+    // Set up a minimal git repo
+    run("git init -b main", base);
+    run('git config user.name "Pi Test"', base);
+    run('git config user.email "pi@example.com"', base);
+    run('git remote add origin git@github.com:example/repo.git', base);
+    writeFileSync(join(base, "README.md"), "# Test Repo\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "chore: init"', base);
+
+    const externalPath = externalGsdRoot(base);
+
+    // ── Test: numbered variant directories are cleaned up ──────────────
+    console.log("\n=== ensureGsdSymlink removes numbered .gsd variants (#2205) ===");
+    {
+      // Simulate macOS creating numbered variants: ".gsd 2", ".gsd 3"
+      mkdirSync(join(base, ".gsd 2"), { recursive: true });
+      mkdirSync(join(base, ".gsd 3"), { recursive: true });
+      mkdirSync(join(base, ".gsd 4"), { recursive: true });
+
+      const result = ensureGsdSymlink(base);
+      assertEq(result, externalPath, "ensureGsdSymlink returns external path");
+      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists after ensureGsdSymlink");
+      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+
+      // The numbered variants must have been removed
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" directory was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" directory was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 4")), '".gsd 4" directory was cleaned up');
+    }
+
+    // ── Test: numbered variant symlinks are cleaned up ─────────────────
+    console.log("\n=== ensureGsdSymlink removes numbered symlink variants ===");
+    {
+      // Clean slate
+      rmSync(join(base, ".gsd"), { recursive: true, force: true });
+
+      // Simulate: ".gsd 2" is a symlink to the correct target (the real .gsd)
+      // and ".gsd" doesn't exist — this is the actual macOS scenario
+      const staleTarget = join(stateDir, "projects", "stale-target");
+      mkdirSync(staleTarget, { recursive: true });
+      symlinkSync(externalPath, join(base, ".gsd 2"), "junction");
+      symlinkSync(staleTarget, join(base, ".gsd 3"), "junction");
+
+      const result = ensureGsdSymlink(base);
+      assertEq(result, externalPath, "ensureGsdSymlink returns external path when variants exist");
+      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists");
+      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" symlink variant was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" symlink variant was cleaned up');
+    }
+
+    // ── Test: real .gsd directory blocks symlink, but variants still cleaned ──
+    console.log("\n=== ensureGsdSymlink cleans variants even when .gsd is a real directory ===");
+    {
+      // Clean slate
+      rmSync(join(base, ".gsd"), { recursive: true, force: true });
+
+      // .gsd is a real directory (git-tracked) and numbered variants exist
+      mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+      writeFileSync(join(base, ".gsd", "milestones", "M001.md"), "# M001\n", "utf-8");
+      mkdirSync(join(base, ".gsd 2"), { recursive: true });
+      mkdirSync(join(base, ".gsd 3"), { recursive: true });
+
+      const result = ensureGsdSymlink(base);
+      // When .gsd is a real directory, ensureGsdSymlink preserves it
+      assertEq(result, join(base, ".gsd"), "real .gsd directory preserved");
+      assertTrue(lstatSync(join(base, ".gsd")).isDirectory(), ".gsd remains a directory");
+
+      // But the numbered variants should still be cleaned up
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" cleaned even when .gsd is a directory');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" cleaned even when .gsd is a directory');
+    }
+
+    // ── Test: only numeric-suffixed variants are removed ───────────────
+    console.log("\n=== ensureGsdSymlink only removes .gsd + space + digit variants ===");
+    {
+      rmSync(join(base, ".gsd"), { recursive: true, force: true });
+
+      // These should NOT be touched
+      mkdirSync(join(base, ".gsd-backup"), { recursive: true });
+      mkdirSync(join(base, ".gsd_old"), { recursive: true });
+
+      // These SHOULD be removed (macOS collision pattern)
+      mkdirSync(join(base, ".gsd 2"), { recursive: true });
+      mkdirSync(join(base, ".gsd 10"), { recursive: true });
+
+      ensureGsdSymlink(base);
+
+      assertTrue(existsSync(join(base, ".gsd-backup")), ".gsd-backup is NOT removed");
+      assertTrue(existsSync(join(base, ".gsd_old")), ".gsd_old is NOT removed");
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" removed');
+      assertTrue(!existsSync(join(base, ".gsd 10")), '".gsd 10" removed');
+
+      // Cleanup non-variant dirs
+      rmSync(join(base, ".gsd-backup"), { recursive: true, force: true });
+      rmSync(join(base, ".gsd_old"), { recursive: true, force: true });
+    }
+
+  } finally {
+    delete process.env.GSD_STATE_DIR;
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+    try { rmSync(stateDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    report();
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -118,6 +118,51 @@ console.log('\n── Loop guard: arg order is normalized ──');
   assertEq(getToolCallLoopCount(), 2, 'Should detect as same call regardless of key order');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Nested/array arguments produce distinct hashes
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: nested args are not stripped ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // Simulate ask_user_questions-style calls with different nested content
+  for (let i = 1; i <= 5; i++) {
+    const result = checkToolCallLoop('ask_user_questions', {
+      questions: [{ id: `q${i}`, question: `Question ${i}?` }],
+    });
+    assertTrue(result.block === false, `Nested call ${i} with unique content should be allowed`);
+    assertEq(getToolCallLoopCount(), 1, `Each unique nested call should reset count to 1`);
+  }
+
+  // Truly identical nested calls should still be detected
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    checkToolCallLoop('ask_user_questions', {
+      questions: [{ id: 'same', question: 'Same?' }],
+    });
+  }
+  const blocked = checkToolCallLoop('ask_user_questions', {
+    questions: [{ id: 'same', question: 'Same?' }],
+  });
+  assertTrue(blocked.block === true, 'Identical nested calls should still be blocked');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Nested object key order is normalized
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: nested key order is normalized ──');
+
+{
+  resetToolCallLoopGuard();
+
+  checkToolCallLoop('tool', { outer: { b: 2, a: 1 } });
+  const result = checkToolCallLoop('tool', { outer: { a: 1, b: 2 } });
+  assertEq(getToolCallLoopCount(), 2, 'Same nested args in different key order should match');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 
 report();