gsd-pi 2.41.0-dev.cac69f9 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/run-manager.test.ts

@@ -0,0 +1,229 @@
+/**
+ * run-manager.test.ts — Tests for run directory creation and listing.
+ *
+ * Uses real temp directories with actual definition YAML files and
+ * GRAPH.yaml persistence — no mocks.
+ */
+
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  readdirSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { parse } from "yaml";
+
+import { createRun, listRuns } from "../run-manager.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "run-mgr-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const d of tmpDirs) {
+    try { rmSync(d, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
+  tmpDirs.length = 0;
+});
+
+/** Write a minimal valid workflow definition YAML to the expected location. */
+function writeDefinition(
+  basePath: string,
+  name: string,
+  content: string,
+): void {
+  const defsDir = join(basePath, ".gsd", "workflow-defs");
+  mkdirSync(defsDir, { recursive: true });
+  writeFileSync(join(defsDir, `${name}.yaml`), content, "utf-8");
+}
+
+const SIMPLE_DEF = `
+version: 1
+name: test-workflow
+description: A test workflow
+steps:
+  - id: step-1
+    name: First Step
+    prompt: Do step 1
+    requires: []
+    produces: []
+  - id: step-2
+    name: Second Step
+    prompt: Do step 2
+    requires:
+      - step-1
+    produces: []
+`;
+
+const PARAMETERIZED_DEF = `
+version: 1
+name: param-workflow
+description: A parameterized workflow
+params:
+  target: default-target
+steps:
+  - id: step-1
+    name: Build
+    prompt: "Build {{target}}"
+    requires: []
+    produces: []
+`;
+
+// ─── createRun ───────────────────────────────────────────────────────────
+
+describe("createRun", () => {
+  it("creates directory structure with DEFINITION.yaml and GRAPH.yaml", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "test-workflow", SIMPLE_DEF);
+
+    const runDir = createRun(base, "test-workflow");
+
+    // Run directory exists
+    assert.ok(existsSync(runDir), "run directory should exist");
+
+    // DEFINITION.yaml exists and contains the definition
+    const defPath = join(runDir, "DEFINITION.yaml");
+    assert.ok(existsSync(defPath), "DEFINITION.yaml should exist");
+    const defContent = parse(readFileSync(defPath, "utf-8"));
+    assert.equal(defContent.name, "test-workflow");
+    assert.equal(defContent.steps.length, 2);
+
+    // GRAPH.yaml exists with all steps pending
+    const graphPath = join(runDir, "GRAPH.yaml");
+    assert.ok(existsSync(graphPath), "GRAPH.yaml should exist");
+    const graphContent = parse(readFileSync(graphPath, "utf-8"));
+    assert.equal(graphContent.steps.length, 2);
+    assert.equal(graphContent.steps[0].status, "pending");
+    assert.equal(graphContent.steps[1].status, "pending");
+    assert.equal(graphContent.metadata.name, "test-workflow");
+
+    // No PARAMS.json without overrides
+    assert.ok(!existsSync(join(runDir, "PARAMS.json")), "PARAMS.json should not exist without overrides");
+
+    // Run directory path matches convention
+    assert.ok(runDir.includes(join(".gsd", "workflow-runs", "test-workflow")), "path should follow convention");
+  });
+
+  it("writes PARAMS.json and substituted prompts when overrides provided", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "param-workflow", PARAMETERIZED_DEF);
+
+    const runDir = createRun(base, "param-workflow", { target: "my-app" });
+
+    // PARAMS.json exists with overrides
+    const paramsPath = join(runDir, "PARAMS.json");
+    assert.ok(existsSync(paramsPath), "PARAMS.json should exist");
+    const params = JSON.parse(readFileSync(paramsPath, "utf-8"));
+    assert.deepStrictEqual(params, { target: "my-app" });
+
+    // DEFINITION.yaml has substituted prompts
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const defContent = parse(readFileSync(defPath, "utf-8"));
+    assert.equal(defContent.steps[0].prompt, "Build my-app");
+
+    // GRAPH.yaml also has substituted prompts
+    const graphPath = join(runDir, "GRAPH.yaml");
+    const graphContent = parse(readFileSync(graphPath, "utf-8"));
+    assert.equal(graphContent.steps[0].prompt, "Build my-app");
+  });
+
+  it("throws for unknown definition", () => {
+    const base = makeTmpBase();
+    // Don't write any definition file
+
+    assert.throws(
+      () => createRun(base, "nonexistent"),
+      (err: Error) => err.message.includes("not found"),
+    );
+  });
+
+  it("uses filesystem-safe timestamp directory names", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "test-workflow", SIMPLE_DEF);
+
+    const runDir = createRun(base, "test-workflow");
+
+    // Extract the timestamp directory name (use path.sep for cross-platform)
+    const timestamp = runDir.split(/[/\\]/).pop()!;
+
+    // Should not contain colons (filesystem-unsafe on Windows)
+    assert.ok(!timestamp.includes(":"), `timestamp should not contain colons: ${timestamp}`);
+    // Should match YYYY-MM-DDTHH-MM-SS pattern
+    assert.match(timestamp, /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
+  });
+});
+
+// ─── listRuns ────────────────────────────────────────────────────────────
+
+describe("listRuns", () => {
+  it("returns empty array when no runs exist", () => {
+    const base = makeTmpBase();
+    const runs = listRuns(base);
+    assert.deepStrictEqual(runs, []);
+  });
+
+  it("returns correct metadata for existing runs", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "test-workflow", SIMPLE_DEF);
+
+    // Create a run
+    const runDir = createRun(base, "test-workflow");
+
+    const runs = listRuns(base);
+    assert.equal(runs.length, 1);
+    assert.equal(runs[0].name, "test-workflow");
+    assert.equal(runs[0].runDir, runDir);
+    assert.equal(runs[0].steps.total, 2);
+    assert.equal(runs[0].steps.completed, 0);
+    assert.equal(runs[0].steps.pending, 2);
+    assert.equal(runs[0].steps.active, 0);
+    assert.equal(runs[0].status, "pending");
+  });
+
+  it("filters by definition name", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "test-workflow", SIMPLE_DEF);
+    writeDefinition(base, "param-workflow", PARAMETERIZED_DEF);
+
+    createRun(base, "test-workflow");
+    createRun(base, "param-workflow", { target: "app" });
+
+    const allRuns = listRuns(base);
+    assert.equal(allRuns.length, 2);
+
+    const filtered = listRuns(base, "test-workflow");
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].name, "test-workflow");
+  });
+
+  it("returns newest-first within same definition", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "test-workflow", SIMPLE_DEF);
+
+    const run1 = createRun(base, "test-workflow");
+    // Ensure different timestamp by creating run dir manually with earlier timestamp
+    const earlyDir = join(base, ".gsd", "workflow-runs", "test-workflow", "2020-01-01T00-00-00");
+    mkdirSync(earlyDir, { recursive: true });
+    // Copy GRAPH.yaml to make it a valid run
+    const graphContent = readFileSync(join(run1, "GRAPH.yaml"), "utf-8");
+    writeFileSync(join(earlyDir, "GRAPH.yaml"), graphContent, "utf-8");
+
+    const runs = listRuns(base, "test-workflow");
+    assert.equal(runs.length, 2);
+    // First should be the newer one (the one we just created)
+    assert.ok(runs[0].timestamp > runs[1].timestamp, "should be sorted newest-first");
+  });
+});

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

@@ -4,8 +4,8 @@ import assert from "node:assert/strict";
 import {
   supportsServiceTier,
   formatServiceTierStatus,
+  formatServiceTierFooterStatus,
   resolveServiceTierIcon,
-  type ServiceTierSetting,
 } from "../service-tier.ts";
 
 // ─── supportsServiceTier ─────────────────────────────────────────────────────
@@ -27,6 +27,14 @@ describe("supportsServiceTier", () => {
     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);
   });
@@ -52,6 +60,11 @@ describe("formatServiceTierStatus", () => {
     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}`);
@@ -63,6 +76,22 @@ describe("formatServiceTierStatus", () => {
   });
 });
 
+// ─── 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", () => {

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/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();