gsd-pi 2.18.0 → 2.20.0

package/dist/resources/extensions/gsd/tests/routing-history.test.ts

@@ -1,87 +1,240 @@
-/**
- * Routing History — structural tests for adaptive learning module.
- *
- * Verifies routing-history.ts exports and structure from #579.
- * Uses source-level checks to avoid @gsd/pi-coding-agent import chain.
- */
-
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const historySrc = readFileSync(join(__dirname, "..", "routing-history.ts"), "utf-8");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Module Exports
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: exports initRoutingHistory", () => {
-  assert.ok(historySrc.includes("export function initRoutingHistory"), "should export initRoutingHistory");
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  initRoutingHistory,
+  resetRoutingHistory,
+  recordOutcome,
+  recordFeedback,
+  getAdaptiveTierAdjustment,
+  clearRoutingHistory,
+  getRoutingHistory,
+} from "../routing-history.js";
+
+// ─── Test Setup ──────────────────────────────────────────────────────────────
+
+function makeTmpDir(): string {
+  const dir = join(tmpdir(), `gsd-routing-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+  resetRoutingHistory();
+}
+
+// ─── recordOutcome ───────────────────────────────────────────────────────────
+
+test("recordOutcome tracks success and failure counts", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", false);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    const pattern = history.patterns["execute-task"];
+    assert.ok(pattern);
+    assert.equal(pattern.standard.success, 2);
+    assert.equal(pattern.standard.fail, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports recordOutcome", () => {
-  assert.ok(historySrc.includes("export function recordOutcome"), "should export recordOutcome");
+test("recordOutcome tracks tag-specific patterns", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", true, ["docs"]);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.ok(history.patterns["execute-task:docs"]);
+    assert.equal(history.patterns["execute-task:docs"].light.success, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports recordFeedback", () => {
-  assert.ok(historySrc.includes("export function recordFeedback"), "should export recordFeedback");
+test("recordOutcome applies rolling window", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Record 60 successes — should be capped to 50
+    for (let i = 0; i < 60; i++) {
+      recordOutcome("execute-task", "standard", true);
+    }
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    const total = history.patterns["execute-task"].standard.success +
+                  history.patterns["execute-task"].standard.fail;
+    assert.ok(total <= 50, `total ${total} should be <= 50`);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports getAdaptiveTierAdjustment", () => {
-  assert.ok(historySrc.includes("export function getAdaptiveTierAdjustment"), "should export getAdaptiveTierAdjustment");
+// ─── getAdaptiveTierAdjustment ───────────────────────────────────────────────
+
+test("no adjustment when insufficient data", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", false);
+    // Only 1 data point — not enough
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: exports resetRoutingHistory", () => {
-  assert.ok(historySrc.includes("export function resetRoutingHistory"), "should export resetRoutingHistory");
+test("bumps tier when failure rate exceeds threshold", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Record high failure rate at light tier
+    recordOutcome("execute-task", "light", false);
+    recordOutcome("execute-task", "light", false);
+    recordOutcome("execute-task", "light", true);
+    // 2/3 = 66% failure rate > 20% threshold
+
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, "standard");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Design Constants
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: uses rolling window of 50 entries", () => {
-  assert.ok(historySrc.includes("ROLLING_WINDOW = 50"), "should use 50-entry rolling window");
+test("no adjustment when success rate is high", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    for (let i = 0; i < 10; i++) {
+      recordOutcome("execute-task", "light", true);
+    }
+    const adj = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adj, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: failure threshold is 20%", () => {
-  assert.ok(historySrc.includes("FAILURE_THRESHOLD = 0.20"), "should use 20% failure threshold");
+test("tag-specific patterns take precedence", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    // Base pattern has high success rate (tagged calls also count toward base)
+    for (let i = 0; i < 15; i++) {
+      recordOutcome("execute-task", "light", true);
+    }
+    // But docs-tagged tasks fail at light
+    recordOutcome("execute-task", "light", false, ["docs"]);
+    recordOutcome("execute-task", "light", false, ["docs"]);
+    recordOutcome("execute-task", "light", true, ["docs"]);
+
+    // With tags, should bump (docs pattern: 1/3 success = 66% failure)
+    const adj = getAdaptiveTierAdjustment("execute-task", "light", ["docs"]);
+    assert.equal(adj, "standard");
+
+    // Without tags, should not bump (base: 16/18 success = 11% failure)
+    const adjBase = getAdaptiveTierAdjustment("execute-task", "light");
+    assert.equal(adjBase, null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: feedback weight is 2x", () => {
-  assert.ok(historySrc.includes("FEEDBACK_WEIGHT = 2"), "feedback should count 2x");
+// ─── recordFeedback ──────────────────────────────────────────────────────────
+
+test("recordFeedback stores feedback entries", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.equal(history.feedback.length, 1);
+    assert.equal(history.feedback[0].rating, "over");
+    assert.equal(history.feedback[0].tier, "standard");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Type Structure
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: imports ComplexityTier from types.ts", () => {
-  assert.ok(
-    historySrc.includes('from "./types.js"') && historySrc.includes("ComplexityTier"),
-    "should import ComplexityTier from types.ts",
-  );
-});
-
-test("routing-history: defines RoutingHistoryData interface", () => {
-  assert.ok(historySrc.includes("interface RoutingHistoryData"), "should define RoutingHistoryData");
+test("recordFeedback 'under' increases failure count at tier", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "light", "under");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    // "under" adds 2 (FEEDBACK_WEIGHT) failures
+    assert.equal(history.patterns["execute-task"].light.fail, 2);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: defines FeedbackEntry interface", () => {
-  assert.ok(historySrc.includes("interface FeedbackEntry"), "should define FeedbackEntry");
+test("recordFeedback 'over' increases success count at lower tier", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    // "over" at standard → adds 2 successes at light
+    assert.equal(history.patterns["execute-task"].light.success, 2);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Persistence
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("routing-history: persists to routing-history.json", () => {
-  assert.ok(historySrc.includes("routing-history.json"), "should persist to routing-history.json");
+// ─── clearRoutingHistory ─────────────────────────────────────────────────────
+
+test("clearRoutingHistory resets all data", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "light", true);
+    clearRoutingHistory(dir);
+
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.deepEqual(history.patterns, {});
+    assert.deepEqual(history.feedback, []);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("routing-history: has save and load functions", () => {
-  assert.ok(historySrc.includes("saveHistory") || historySrc.includes("function save"), "should have save");
-  assert.ok(historySrc.includes("loadHistory") || historySrc.includes("function load"), "should have load");
+// ─── Persistence ─────────────────────────────────────────────────────────────
+
+test("routing history persists to disk and reloads", () => {
+  const dir = makeTmpDir();
+  try {
+    initRoutingHistory(dir);
+    recordOutcome("execute-task", "standard", true);
+    recordOutcome("execute-task", "standard", true);
+    resetRoutingHistory();
+
+    // Reload from disk
+    initRoutingHistory(dir);
+    const history = getRoutingHistory();
+    assert.ok(history);
+    assert.equal(history.patterns["execute-task"].standard.success, 2);
+  } finally {
+    cleanup(dir);
+  }
 });

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

@@ -0,0 +1,126 @@
+/**
+ * Tests for skill telemetry and skill health (#599).
+ * Tests the pure functions — no file I/O, no extension context.
+ */
+
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import type { UnitMetrics } from "../metrics.js";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeUnit(overrides: Partial<UnitMetrics> = {}): UnitMetrics {
+  return {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    model: "claude-sonnet-4-20250514",
+    startedAt: 1000,
+    finishedAt: 2000,
+    tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 },
+    cost: 0.05,
+    toolCalls: 3,
+    assistantMessages: 5,
+    userMessages: 2,
+    ...overrides,
+  };
+}
+
+// ─── Skill Telemetry ──────────────────────────────────────────────────────────
+
+describe("skill-telemetry", () => {
+  // Note: captureAvailableSkills/getAndClearSkills depend on filesystem (getAgentDir)
+  // so we test the data flow via getSkillLastUsed and detectStaleSkills which are pure
+
+  it("getSkillLastUsed returns most recent timestamp per skill", async () => {
+    const { getSkillLastUsed } = await import("../skill-telemetry.js");
+
+    const units = [
+      makeUnit({ finishedAt: 1000, skills: ["rust-core", "axum-web-framework"] }),
+      makeUnit({ finishedAt: 2000, skills: ["rust-core"] }),
+      makeUnit({ finishedAt: 3000, skills: ["axum-web-framework"] }),
+    ];
+
+    const result = getSkillLastUsed(units);
+    assert.equal(result.get("rust-core"), 2000);
+    assert.equal(result.get("axum-web-framework"), 3000);
+  });
+
+  it("getSkillLastUsed returns empty map for units without skills", async () => {
+    const { getSkillLastUsed } = await import("../skill-telemetry.js");
+
+    const units = [makeUnit(), makeUnit()];
+    const result = getSkillLastUsed(units);
+    assert.equal(result.size, 0);
+  });
+});
+
+// ─── Skill Health ─────────────────────────────────────────────────────────────
+
+describe("skill-health", () => {
+  it("buildHealSkillPrompt includes unit ID", async () => {
+    const { buildHealSkillPrompt } = await import("../skill-health.js");
+    const prompt = buildHealSkillPrompt("M001/S01/T01");
+    assert.ok(prompt.includes("M001/S01/T01"));
+    assert.ok(prompt.includes("Skill Heal Analysis"));
+    assert.ok(prompt.includes("skill-review-queue.md"));
+  });
+
+  it("computeStaleAvoidList excludes already-avoided skills", async () => {
+    // This test requires filesystem access for loadLedgerFromDisk
+    // so we test the filtering logic conceptually
+    const { computeStaleAvoidList } = await import("../skill-health.js");
+
+    // With no metrics file, should return empty
+    const result = computeStaleAvoidList("/nonexistent/path", ["some-skill"]);
+    assert.ok(Array.isArray(result));
+  });
+});
+
+// ─── UnitMetrics skills field ─────────────────────────────────────────────────
+
+describe("UnitMetrics skills field", () => {
+  it("skills field is optional and accepts string array", () => {
+    const unit = makeUnit({ skills: ["rust-core", "axum-web-framework"] });
+    assert.deepEqual(unit.skills, ["rust-core", "axum-web-framework"]);
+  });
+
+  it("skills field is undefined when not provided", () => {
+    const unit = makeUnit();
+    assert.equal(unit.skills, undefined);
+  });
+});
+
+// ─── Preferences ──────────────────────────────────────────────────────────────
+
+describe("skill_staleness_days preference", () => {
+  it("validates valid staleness days", async () => {
+    const { validatePreferences } = await import("../preferences.js");
+
+    const result = validatePreferences({ skill_staleness_days: 30 });
+    assert.equal(result.preferences.skill_staleness_days, 30);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it("validates zero (disabled) staleness days", async () => {
+    const { validatePreferences } = await import("../preferences.js");
+
+    const result = validatePreferences({ skill_staleness_days: 0 });
+    assert.equal(result.preferences.skill_staleness_days, 0);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it("rejects negative staleness days", async () => {
+    const { validatePreferences } = await import("../preferences.js");
+
+    const result = validatePreferences({ skill_staleness_days: -5 });
+    assert.equal(result.preferences.skill_staleness_days, undefined);
+    assert.ok(result.errors.some(e => e.includes("skill_staleness_days")));
+  });
+
+  it("floors fractional days", async () => {
+    const { validatePreferences } = await import("../preferences.js");
+
+    const result = validatePreferences({ skill_staleness_days: 30.7 });
+    assert.equal(result.preferences.skill_staleness_days, 30);
+  });
+});

package/dist/resources/extensions/gsd/tests/stop-auto-remote.test.ts

@@ -4,7 +4,7 @@ import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
-import { fork } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 
 import { writeFileSync } from "node:fs";
 import {
@@ -25,6 +25,27 @@ function cleanup(base: string): void {
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function waitForChildExit(child: ChildProcess, timeoutMs = 5000): Promise<number | null> {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null) {
+      resolve(child.exitCode);
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      child.off("exit", onExit);
+      resolve(child.exitCode);
+    }, timeoutMs);
+
+    const onExit = (code: number | null) => {
+      clearTimeout(timeout);
+      resolve(code);
+    };
+
+    child.once("exit", onExit);
+  });
+}
+
 // ─── stopAutoRemote ──────────────────────────────────────────────────────
 
 test("stopAutoRemote returns found:false when no lock file exists", () => {
@@ -63,12 +84,16 @@ test("stopAutoRemote sends SIGTERM to a live process and returns found:true", as
   const base = makeTmpBase();
 
   // Spawn a child process that sleeps, acting as a fake auto-mode session
-  const child = fork(
-    "-e",
-    ["process.on('SIGTERM', () => process.exit(0)); setTimeout(() => process.exit(1), 30000);"],
+  const child = spawn(
+    process.execPath,
+    ["-e", "process.on('SIGTERM', () => process.exit(0)); setTimeout(() => process.exit(1), 30000);"],
     { stdio: "ignore", detached: false },
   );
 
+  if (!child.pid) {
+    throw new Error("failed to spawn child process for stopAutoRemote test");
+  }
+
   try {
     // Wait for child to be ready
     await new Promise((resolve) => setTimeout(resolve, 200));
@@ -84,15 +109,13 @@ test("stopAutoRemote sends SIGTERM to a live process and returns found:true", as
     };
     writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2), "utf-8");
 
+    const exitPromise = waitForChildExit(child);
     const result = stopAutoRemote(base);
     assert.equal(result.found, true, "should find running auto-mode");
     assert.equal(result.pid, child.pid, "should return the PID");
 
     // Wait for child to exit (it should receive SIGTERM)
-    const exitCode = await new Promise<number | null>((resolve) => {
-      child.on("exit", (code) => resolve(code));
-      setTimeout(() => resolve(null), 5000);
-    });
+    const exitCode = await exitPromise;
     // On Windows, SIGTERM is not interceptable — the process exits with code 1
     // rather than running the handler. Accept either clean exit (0) or forced (1).
     assert.ok(exitCode !== null, "child should have exited after SIGTERM");