gsd-pi 2.18.0 → 2.19.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/triage-dispatch.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Triage dispatch ordering contract tests.
+ *
+ * These tests verify structural invariants of the triage integration
+ * by inspecting the actual source code of auto.ts and post-unit-hooks.ts.
+ * Full behavioral testing requires the @gsd/pi-coding-agent runtime.
+ */
+
+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 autoPath = join(__dirname, "..", "auto.ts");
+const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
+const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
+
+const autoSrc = readFileSync(autoPath, "utf-8");
+const hooksSrc = readFileSync(hooksPath, "utf-8");
+const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
+
+// ─── Hook exclusion ──────────────────────────────────────────────────────────
+
+test("dispatch: triage-captures excluded from post-unit hook triggering", () => {
+  // post-unit-hooks.ts must return null for triage-captures unit type
+  assert.ok(
+    hooksSrc.includes('"triage-captures"'),
+    "post-unit-hooks.ts should reference triage-captures",
+  );
+  assert.ok(
+    hooksSrc.includes('completedUnitType === "triage-captures"'),
+    "should check for triage-captures in the hook exclusion guard",
+  );
+});
+
+// ─── Triage check placement ──────────────────────────────────────────────────
+
+test("dispatch: triage check appears after hook section and before stepMode check", () => {
+  const hookRetryIndex = autoSrc.indexOf("isRetryPending()");
+  // Find the triage check in handleAgentEnd (not in getAutoDashboardData)
+  const triageCheckIndex = autoSrc.indexOf("Triage check: dispatch triage unit");
+  const stepModeIndex = autoSrc.indexOf("In step mode, pause and show a wizard");
+
+  assert.ok(hookRetryIndex > 0, "hook retry check should exist");
+  assert.ok(triageCheckIndex > 0, "triage check block should exist");
+  assert.ok(stepModeIndex > 0, "step mode check should exist");
+
+  assert.ok(
+    triageCheckIndex > hookRetryIndex,
+    "triage check should come after hook retry check",
+  );
+  assert.ok(
+    triageCheckIndex < stepModeIndex,
+    "triage check should come before stepMode check",
+  );
+});
+
+// ─── Guard conditions ────────────────────────────────────────────────────────
+
+test("dispatch: triage check guards against step mode", () => {
+  // The triage block should check !stepMode
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes("!stepMode"),
+    "triage block should guard against step mode",
+  );
+});
+
+test("dispatch: triage check guards against hook unit types", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('!currentUnit.type.startsWith("hook/")'),
+    "triage block should not fire for hook units",
+  );
+});
+
+test("dispatch: triage check guards against triage-on-triage", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('currentUnit.type !== "triage-captures"'),
+    "triage block should not fire for triage units",
+  );
+});
+
+test("dispatch: triage check guards against quick-task triggering triage", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('currentUnit.type !== "quick-task"'),
+    "triage block should not fire for quick-task units",
+  );
+});
+
+test("dispatch: triage dispatch uses early-return pattern", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes("return; // handleAgentEnd will fire again"),
+    "triage dispatch should return after sending message",
+  );
+});
+
+test("dispatch: triage imports hasPendingCaptures and loadPendingCaptures", () => {
+  assert.ok(
+    autoSrc.includes('hasPendingCaptures, loadPendingCaptures, countPendingCaptures') &&
+    autoSrc.includes('from "./captures.js"'),
+    "auto.ts should import capture functions including countPendingCaptures",
+  );
+});
+
+// ─── Prompt integration ──────────────────────────────────────────────────────
+
+test("dispatch: replan prompt builder loads capture context", () => {
+  const src = autoPromptsSrc;
+  assert.ok(
+    src.includes("loadReplanCaptures"),
+    "buildReplanSlicePrompt should load replan captures",
+  );
+  assert.ok(
+    src.includes("captureContext"),
+    "buildReplanSlicePrompt should pass captureContext to template",
+  );
+});
+
+test("dispatch: reassess prompt builder loads deferred captures", () => {
+  const src = autoPromptsSrc;
+  assert.ok(
+    src.includes("loadDeferredCaptures"),
+    "buildReassessRoadmapPrompt should load deferred captures",
+  );
+  assert.ok(
+    src.includes("deferredCaptures"),
+    "buildReassessRoadmapPrompt should pass deferredCaptures to template",
+  );
+});
+
+// ─── Prompt templates ────────────────────────────────────────────────────────
+
+test("dispatch: replan prompt template includes captureContext variable", () => {
+  const promptPath = join(__dirname, "..", "prompts", "replan-slice.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(
+    prompt.includes("{{captureContext}}"),
+    "replan-slice.md should include {{captureContext}}",
+  );
+});
+
+test("dispatch: reassess prompt template includes deferredCaptures variable", () => {
+  const promptPath = join(__dirname, "..", "prompts", "reassess-roadmap.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(
+    prompt.includes("{{deferredCaptures}}"),
+    "reassess-roadmap.md should include {{deferredCaptures}}",
+  );
+});
+
+test("dispatch: triage prompt template exists and has classification criteria", () => {
+  const promptPath = join(__dirname, "..", "prompts", "triage-captures.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(prompt.includes("quick-task"), "should have quick-task classification");
+  assert.ok(prompt.includes("inject"), "should have inject classification");
+  assert.ok(prompt.includes("defer"), "should have defer classification");
+  assert.ok(prompt.includes("replan"), "should have replan classification");
+  assert.ok(prompt.includes("note"), "should have note classification");
+  assert.ok(prompt.includes("{{pendingCaptures}}"), "should have pending captures variable");
+});
+
+// ─── Dashboard integration ───────────────────────────────────────────────────
+
+test("dashboard: AutoDashboardData includes pendingCaptureCount field", () => {
+  assert.ok(
+    autoSrc.includes("pendingCaptureCount"),
+    "auto.ts should have pendingCaptureCount in AutoDashboardData",
+  );
+});
+
+test("dashboard: getAutoDashboardData computes pendingCaptureCount", () => {
+  assert.ok(
+    autoSrc.includes("pendingCaptureCount = countPendingCaptures") ||
+    autoSrc.includes("pendingCaptureCount = countPendingCaptures(basePath)"),
+    "getAutoDashboardData should compute pendingCaptureCount from countPendingCaptures (single-read)",
+  );
+});
+
+test("dashboard: overlay renders pending captures badge", () => {
+  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
+  const overlaySrc = readFileSync(overlayPath, "utf-8");
+  assert.ok(
+    overlaySrc.includes("pendingCaptureCount"),
+    "dashboard-overlay.ts should reference pendingCaptureCount",
+  );
+  assert.ok(
+    overlaySrc.includes("pending capture"),
+    "dashboard-overlay.ts should show pending captures text",
+  );
+});
+
+test("dashboard: overlay labels triage-captures and quick-task unit types", () => {
+  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
+  const overlaySrc = readFileSync(overlayPath, "utf-8");
+  assert.ok(
+    overlaySrc.includes('"triage-captures"'),
+    "unitLabel should handle triage-captures",
+  );
+  assert.ok(
+    overlaySrc.includes('"quick-task"'),
+    "unitLabel should handle quick-task",
+  );
+});