gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

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

@@ -0,0 +1,98 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  supportsServiceTier,
+  formatServiceTierStatus,
+  resolveServiceTierIcon,
+  type ServiceTierSetting,
+} 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 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("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}`);
+  });
+});
+
+// ─── 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-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/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();

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

@@ -0,0 +1,117 @@
+// tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
+//
+// Each of the 4 DB tools must register under its canonical gsd_concept_action name
+// AND under the old gsd_action_concept name as a backward-compatible alias.
+// The alias must share the exact same execute function reference as the canonical tool.
+
+import { createTestContext } from './test-helpers.ts';
+import { registerDbTools } from '../bootstrap/db-tools.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Mock PI ──────────────────────────────────────────────────────────────────
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+// ─── Rename map ───────────────────────────────────────────────────────────────
+
+const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
+  { canonical: "gsd_decision_save", alias: "gsd_save_decision" },
+  { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
+  { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
+  { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
+];
+
+// ─── Registration count ──────────────────────────────────────────────────────
+
+console.log('\n── Tool naming: registration count ──');
+
+const pi = makeMockPi();
+registerDbTools(pi);
+
+assertEq(pi.tools.length, 8, 'Should register exactly 8 tools (4 canonical + 4 aliases)');
+
+// ─── Both names exist for each pair ──────────────────────────────────────────
+
+console.log('\n── Tool naming: canonical and alias names exist ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  assertTrue(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
+  assertTrue(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
+}
+
+// ─── Execute function identity ───────────────────────────────────────────────
+
+console.log('\n── Tool naming: execute function identity (===) ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (canonicalTool && aliasTool) {
+    assertTrue(
+      canonicalTool.execute === aliasTool.execute,
+      `"${canonical}" and "${alias}" should share the same execute function reference`,
+    );
+  }
+}
+
+// ─── Alias descriptions include "(alias for ...)" ───────────────────────────
+
+console.log('\n── Tool naming: alias descriptions ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (aliasTool) {
+    assertTrue(
+      aliasTool.description.includes(`alias for ${canonical}`),
+      `Alias "${alias}" description should include "alias for ${canonical}"`,
+    );
+  }
+}
+
+// ─── Canonical tools have proper promptGuidelines ────────────────────────────
+
+console.log('\n── Tool naming: canonical promptGuidelines use canonical name ──');
+
+for (const { canonical } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+
+  if (canonicalTool) {
+    const guidelinesText = canonicalTool.promptGuidelines.join(' ');
+    assertTrue(
+      guidelinesText.includes(canonical),
+      `Canonical tool "${canonical}" promptGuidelines should reference its own name`,
+    );
+  }
+}
+
+// ─── Alias promptGuidelines direct to canonical ──────────────────────────────
+
+console.log('\n── Tool naming: alias promptGuidelines redirect to canonical ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (aliasTool) {
+    const guidelinesText = aliasTool.promptGuidelines.join(' ');
+    assertTrue(
+      guidelinesText.includes(`Alias for ${canonical}`),
+      `Alias "${alias}" promptGuidelines should say "Alias for ${canonical}"`,
+    );
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -15,6 +15,7 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
+const registryPath = join(__dirname, "..", "rule-registry.ts");
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
 
 // After decomposition, triage/dispatch logic lives in auto-post-unit.ts
@@ -25,7 +26,11 @@ const autoSrc = [
   postUnitSrc,
   readFileSync(join(__dirname, "..", "auto-start.ts"), "utf-8"),
 ].join("\n");
-const hooksSrc = readFileSync(hooksPath, "utf-8");
+// Hook exclusion logic lives in the rule-registry (facade delegates there)
+const hooksSrc = [
+  readFileSync(hooksPath, "utf-8"),
+  readFileSync(registryPath, "utf-8"),
+].join("\n");
 const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
 
 // ─── Hook exclusion ──────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/windows-path-normalization.test.ts

@@ -0,0 +1,99 @@
+/**
+ * windows-path-normalization.test.ts — Verify Windows backslash paths are
+ * normalised to forward slashes before embedding in bash command strings.
+ *
+ * Regression test for #1436: on Windows, `cd C:\Users\user\project` in bash
+ * strips backslashes (escape characters), producing `C:Usersuserproject`.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── shellEscape + path normalization ──────────────────────────────────────
+
+// Replicate the shellEscape helper from cmux/index.ts
+function shellEscape(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// The bashPath pattern used in subagent/index.ts
+function bashPath(p: string): string {
+  return shellEscape(p.replaceAll("\\", "/"));
+}
+
+console.log("\n=== Windows backslash path normalization (#1436) ===");
+
+// Backslash paths are converted to forward slashes
+assertEq(
+  bashPath("C:\\Users\\user\\project"),
+  "'C:/Users/user/project'",
+  "backslash path normalised to forward slashes in shell-escaped string",
+);
+
+// Unix paths pass through unchanged
+assertEq(
+  bashPath("/home/user/project"),
+  "'/home/user/project'",
+  "Unix path unchanged",
+);
+
+// Mixed separators are normalised
+assertEq(
+  bashPath("C:\\Users/user\\project/src"),
+  "'C:/Users/user/project/src'",
+  "mixed separators normalised",
+);
+
+// Paths with single quotes are still properly escaped
+assertEq(
+  bashPath("C:\\Users\\o'brien\\project"),
+  "'C:/Users/o'\\''brien/project'",
+  "single quote in path is escaped after normalisation",
+);
+
+// UNC paths
+assertEq(
+  bashPath("\\\\server\\share\\dir"),
+  "'//server/share/dir'",
+  "UNC path normalised",
+);
+
+// Empty string
+assertEq(
+  bashPath(""),
+  "''",
+  "empty string handled",
+);
+
+// ─── cd command construction ───────────────────────────────────────────────
+
+console.log("\n=== cd command construction with normalised paths ===");
+
+const windowsCwd = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
+const cdCommand = `cd ${bashPath(windowsCwd)}`;
+assertEq(
+  cdCommand,
+  "cd 'C:/Users/user/project/.gsd/worktrees/M001'",
+  "cd command uses forward slashes for Windows worktree path",
+);
+
+// Verify the mangled form from #1436 is NOT produced
+assertTrue(
+  !cdCommand.includes("C:Users"),
+  "mangled path C:Usersuserproject must not appear",
+);
+
+// ─── Worktree teardown orphan detection ────────────────────────────────────
+
+console.log("\n=== teardown orphan warning path formatting ===");
+
+const windowsWtDir = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
+const helpCommand = `rm -rf "${windowsWtDir.replaceAll("\\", "/")}"`;
+assertEq(
+  helpCommand,
+  'rm -rf "C:/Users/user/project/.gsd/worktrees/M001"',
+  "orphan cleanup help command uses forward slashes",
+);
+
+report();

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

@@ -138,6 +138,7 @@ async function main(): Promise<void> {
         choice: "reconcile on merge",
         rationale: "test coverage",
         revisable: "no",
+        made_by: 'agent',
         superseded_by: null,
       });
       closeDatabase();

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

@@ -47,6 +47,7 @@ function seedMainDb(dbPath: string): void {
     choice: 'node:sqlite',
     rationale: 'Built-in',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertRequirement({
@@ -182,6 +183,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'WAL',
     rationale: 'Performance',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   closeDatabase();
@@ -357,6 +359,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'yes',
     rationale: 'Robustness',
     revisable: 'no',
+    made_by: 'agent',
     superseded_by: null,
   });
   closeDatabase();
@@ -395,6 +398,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'works',
     rationale: 'Verify DETACH cleanup',
     revisable: 'no',
+    made_by: 'agent',
     superseded_by: null,
   });