gsd-pi 2.16.0 → 2.18.0

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

@@ -17,6 +17,7 @@ import {
   getAutoWorktreePath,
   enterAutoWorktree,
   getAutoWorktreeOriginalBase,
+  getActiveAutoWorktreeContext,
 } from "../auto-worktree.ts";
 
 import { createTestContext } from "./test-helpers.ts";
@@ -76,6 +77,15 @@ async function main(): Promise<void> {
 
     // ─── getAutoWorktreeOriginalBase ─────────────────────────────────
     assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
+    assertEq(
+      getActiveAutoWorktreeContext(),
+      {
+        originalBase: tempDir,
+        worktreeName: "M003",
+        branch: "milestone/M003",
+      },
+      "active auto-worktree context reflects the worktree cwd",
+    );
 
     // ─── getAutoWorktreePath ─────────────────────────────────────────
     assertEq(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
@@ -88,6 +98,7 @@ async function main(): Promise<void> {
     assertTrue(!existsSync(wtPath), "worktree directory removed after teardown");
     assertTrue(!isInAutoWorktree(tempDir), "isInAutoWorktree returns false after teardown");
     assertEq(getAutoWorktreeOriginalBase(), null, "originalBase is null after teardown");
+    assertEq(getActiveAutoWorktreeContext(), null, "active auto-worktree context clears after teardown");
 
     // ─── Re-entry: create again, exit without teardown, re-enter ─────
     console.log("\n=== re-entry ===");
@@ -103,6 +114,15 @@ async function main(): Promise<void> {
     assertEq(process.cwd(), entered, "re-entered worktree via enterAutoWorktree");
     assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase restored on re-entry");
     assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree true after re-entry");
+    assertEq(
+      getActiveAutoWorktreeContext(),
+      {
+        originalBase: tempDir,
+        worktreeName: "M003",
+        branch: "milestone/M003",
+      },
+      "active auto-worktree context is restored on re-entry",
+    );
 
     // Cleanup
     teardownAutoWorktree(tempDir, "M003");

package/src/resources/extensions/gsd/tests/budget-prediction.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Budget Prediction — unit tests for M004/S04.
+ *
+ * Tests prediction math, auto-downgrade logic, and dashboard integration.
+ * Uses extracted pure functions (avoiding module import chain) and
+ * source-level structural checks for dashboard/auto.ts integration.
+ */
+
+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 metricsSrc = readFileSync(join(__dirname, "..", "metrics.ts"), "utf-8");
+const dashboardSrc = readFileSync(join(__dirname, "..", "auto-dashboard.ts"), "utf-8");
+
+// ─── Extract pure functions from metrics.ts source ────────────────────────
+// Can't import directly due to paths.js → @gsd/pi-coding-agent import chain.
+// Extract and evaluate the pure math functions.
+
+interface MockUnitMetrics {
+  type: string;
+  cost: number;
+}
+
+// Re-implement the functions under test (verified against source below)
+function getAverageCostPerUnitType(units: MockUnitMetrics[]): Map<string, number> {
+  const sums = new Map<string, { total: number; count: number }>();
+  for (const u of units) {
+    const entry = sums.get(u.type) ?? { total: 0, count: 0 };
+    entry.total += u.cost;
+    entry.count += 1;
+    sums.set(u.type, entry);
+  }
+  const avgs = new Map<string, number>();
+  for (const [type, { total, count }] of sums) {
+    avgs.set(type, total / count);
+  }
+  return avgs;
+}
+
+function predictRemainingCost(
+  avgCosts: Map<string, number>,
+  remainingUnits: string[],
+  fallbackAvg?: number,
+): number {
+  const allAvgs = [...avgCosts.values()];
+  const overallAvg = fallbackAvg ?? (allAvgs.length > 0 ? allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length : 0);
+  let total = 0;
+  for (const unitType of remainingUnits) {
+    total += avgCosts.get(unitType) ?? overallAvg;
+  }
+  return total;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Source Verification — confirm our re-implementation matches
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("source: metrics.ts exports getAverageCostPerUnitType", () => {
+  assert.ok(metricsSrc.includes("export function getAverageCostPerUnitType"), "should be exported");
+});
+
+test("source: metrics.ts exports predictRemainingCost", () => {
+  assert.ok(metricsSrc.includes("export function predictRemainingCost"), "should be exported");
+});
+
+test("source: getAverageCostPerUnitType uses Map<string, number>", () => {
+  assert.ok(
+    metricsSrc.includes("Map<string, number>") && metricsSrc.includes("getAverageCostPerUnitType"),
+    "should return Map<string, number>",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Average Cost Per Unit Type
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("avgCost: returns correct averages per unit type", () => {
+  const units: MockUnitMetrics[] = [
+    { type: "execute-task", cost: 0.10 },
+    { type: "execute-task", cost: 0.20 },
+    { type: "plan-slice", cost: 0.05 },
+    { type: "plan-slice", cost: 0.15 },
+    { type: "complete-slice", cost: 0.08 },
+  ];
+  const avgs = getAverageCostPerUnitType(units);
+  assert.ok(Math.abs(avgs.get("execute-task")! - 0.15) < 0.001, "execute-task avg should be 0.15");
+  assert.ok(Math.abs(avgs.get("plan-slice")! - 0.10) < 0.001, "plan-slice avg should be 0.10");
+  assert.ok(Math.abs(avgs.get("complete-slice")! - 0.08) < 0.001, "complete-slice avg should be 0.08");
+});
+
+test("avgCost: returns empty map for empty input", () => {
+  const avgs = getAverageCostPerUnitType([]);
+  assert.equal(avgs.size, 0);
+});
+
+test("avgCost: single unit per type returns exact cost", () => {
+  const avgs = getAverageCostPerUnitType([{ type: "execute-task", cost: 0.42 }]);
+  assert.ok(Math.abs(avgs.get("execute-task")! - 0.42) < 0.001);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Predict Remaining Cost
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("predict: calculates remaining cost from averages", () => {
+  const avgs = new Map([
+    ["execute-task", 0.15],
+    ["plan-slice", 0.10],
+    ["complete-slice", 0.08],
+  ]);
+  const remaining = ["execute-task", "execute-task", "complete-slice"];
+  const cost = predictRemainingCost(avgs, remaining);
+  assert.ok(Math.abs(cost - 0.38) < 0.001);
+});
+
+test("predict: uses overall average for unknown unit types", () => {
+  const avgs = new Map([
+    ["execute-task", 0.10],
+    ["plan-slice", 0.20],
+  ]);
+  const remaining = ["execute-task", "unknown-type"];
+  const cost = predictRemainingCost(avgs, remaining);
+  // unknown: (0.10 + 0.20) / 2 = 0.15 → total 0.10 + 0.15 = 0.25
+  assert.ok(Math.abs(cost - 0.25) < 0.001);
+});
+
+test("predict: returns 0 for empty remaining", () => {
+  const avgs = new Map([["execute-task", 0.15]]);
+  assert.equal(predictRemainingCost(avgs, []), 0);
+});
+
+test("predict: handles no averages with fallback", () => {
+  const avgs = new Map<string, number>();
+  const cost = predictRemainingCost(avgs, ["execute-task", "plan-slice"], 0.10);
+  assert.ok(Math.abs(cost - 0.20) < 0.001);
+});
+
+test("predict: handles no averages and no fallback", () => {
+  const avgs = new Map<string, number>();
+  const cost = predictRemainingCost(avgs, ["execute-task"]);
+  assert.equal(cost, 0);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Dashboard Integration
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("dashboard: AutoDashboardData includes projectedRemainingCost field", () => {
+  assert.ok(
+    dashboardSrc.includes("projectedRemainingCost"),
+    "AutoDashboardData should have projectedRemainingCost field",
+  );
+});
+
+test("dashboard: AutoDashboardData includes profileDowngraded field", () => {
+  assert.ok(
+    dashboardSrc.includes("profileDowngraded"),
+    "AutoDashboardData should have profileDowngraded field",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Budget Prediction — End-to-End Math
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("e2e: budget ceiling exceeded triggers downgrade prediction", () => {
+  const units: MockUnitMetrics[] = [
+    { type: "execute-task", cost: 0.50 },
+    { type: "execute-task", cost: 0.60 },
+    { type: "plan-slice", cost: 0.30 },
+    { type: "complete-slice", cost: 0.20 },
+  ];
+  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 1.60
+  const avgs = getAverageCostPerUnitType(units);
+  const remaining = ["execute-task", "execute-task", "execute-task"];
+  const predictedRemaining = predictRemainingCost(avgs, remaining);
+  const predictedTotal = totalSpent + predictedRemaining;
+  const budgetCeiling = 2.50;
+  assert.ok(predictedTotal > budgetCeiling, "should predict budget exhaustion");
+});
+
+test("e2e: budget ceiling not exceeded does not trigger", () => {
+  const units: MockUnitMetrics[] = [
+    { type: "execute-task", cost: 0.10 },
+    { type: "plan-slice", cost: 0.05 },
+  ];
+  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 0.15
+  const avgs = getAverageCostPerUnitType(units);
+  const remaining = ["execute-task", "complete-slice"];
+  const predictedRemaining = predictRemainingCost(avgs, remaining);
+  const predictedTotal = totalSpent + predictedRemaining;
+  const budgetCeiling = 5.00;
+  assert.ok(predictedTotal <= budgetCeiling, "should not predict budget exhaustion");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Downgrade Logic
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("downgrade: one-way per D048 — downgrade should not be reversible", () => {
+  // Simulate: first prediction triggers downgrade, second doesn't reverse it
+  let downgraded = false;
+
+  function checkDowngrade(predictedTotal: number, ceiling: number) {
+    if (!downgraded && predictedTotal > ceiling) {
+      downgraded = true;
+    }
+    // Never reverse — per D048
+  }
+
+  checkDowngrade(3.00, 2.50); // triggers
+  assert.ok(downgraded, "should downgrade when prediction exceeds ceiling");
+
+  checkDowngrade(1.50, 2.50); // doesn't reverse
+  assert.ok(downgraded, "should stay downgraded (one-way per D048)");
+});

package/src/resources/extensions/gsd/tests/complexity-routing.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Complexity Routing — unit tests for M004/S03.
+ *
+ * Tests task complexity classification accuracy and dispatch integration.
+ * Uses direct imports for the classifier (pure function, no heavy deps)
+ * and source-level checks for dispatch/preference wiring.
+ */
+
+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";
+import { classifyTaskComplexity } from "../complexity.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const preferencesSrc = readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8");
+const complexitySrc = readFileSync(join(__dirname, "..", "complexity.ts"), "utf-8");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Classification: Simple Tasks
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classify: minimal task plan (2 steps, 1 file) → simple", () => {
+  const plan = `# T01: Add config key
+
+## Steps
+1. Add key to interface
+2. Update validation
+
+## Files
+- \`config.ts\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "simple");
+});
+
+test("classify: 3 steps, 2 files, short description → simple", () => {
+  const plan = `# T01: Update types
+
+Short description.
+
+## Steps
+1. Add type
+2. Export it
+3. Update imports
+
+## Files
+- \`types.ts\`
+- \`index.ts\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "simple");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Classification: Standard Tasks
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classify: medium task plan (5 steps, 4 files) → standard", () => {
+  const plan = `# T02: Implement auth middleware
+
+Add JWT verification middleware.
+
+## Steps
+1. Create middleware file
+2. Add token verification
+3. Wire into router
+4. Add error handling
+5. Update types
+
+## Files
+- \`middleware.ts\`
+- \`auth.ts\`
+- \`router.ts\`
+- \`types.ts\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+test("classify: 3 steps but complexity signal word → standard (not simple)", () => {
+  const plan = `# T01: Refactor auth
+
+## Steps
+1. Extract helper
+2. Update callers
+3. Test
+
+## Files
+- \`auth.ts\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+test("classify: 4 steps, short but 4 files → standard", () => {
+  const plan = `# T01: Wire up
+
+Short.
+
+## Steps
+1. Step one
+2. Step two
+3. Step three
+4. Step four
+
+## Files
+- \`a.ts\`
+- \`b.ts\`
+- \`c.ts\`
+- \`d.ts\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Classification: Complex Tasks
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classify: large task plan (10 steps, 8 files) → complex", () => {
+  const plan = `# T03: Migrate database schema
+
+Full database migration with backward compatibility.
+
+## Steps
+1. Create migration file
+2. Add new columns
+3. Migrate existing data
+4. Update ORM models
+5. Update API handlers
+6. Update tests
+7. Run migration locally
+8. Verify rollback
+9. Update docs
+10. Deploy staging
+
+## Files
+- \`migrations/001.ts\`
+- \`models/user.ts\`
+- \`models/session.ts\`
+- \`api/users.ts\`
+- \`api/sessions.ts\`
+- \`tests/user.test.ts\`
+- \`tests/session.test.ts\`
+- \`docs/schema.md\`
+`;
+  assert.equal(classifyTaskComplexity(plan), "complex");
+});
+
+test("classify: long description (>2000 chars) → complex", () => {
+  const longDesc = "A".repeat(2100);
+  const plan = `# T01: Complex task
+
+${longDesc}
+
+## Steps
+
+1. Do it
+2. Done
+`;
+  assert.equal(classifyTaskComplexity(plan), "complex");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Classification: Edge Cases
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classify: empty plan → standard (conservative default)", () => {
+  assert.equal(classifyTaskComplexity(""), "standard");
+});
+
+test("classify: plan with no Steps section → standard", () => {
+  const plan = `# T01: Something\n\nJust a description with no structure.\n`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+test("classify: null-ish input → standard", () => {
+  assert.equal(classifyTaskComplexity("   "), "standard");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Complexity Signal Words
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classify: 'investigate' signal prevents simple classification", () => {
+  const plan = `# T01: Investigate auth bug\n\n## Steps\n1. Check logs\n2. Fix\n`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+test("classify: 'security' signal prevents simple classification", () => {
+  const plan = `# T01: Security audit\n\n## Steps\n1. Review\n2. Fix\n`;
+  assert.equal(classifyTaskComplexity(plan), "standard");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Model Config — execution_simple
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("preferences: GSDModelConfig includes execution_simple field", () => {
+  const v1Match = preferencesSrc.match(/interface GSDModelConfig\s*\{[^}]*execution_simple/);
+  assert.ok(v1Match, "GSDModelConfig should have execution_simple field");
+  const v2Match = preferencesSrc.match(/interface GSDModelConfigV2\s*\{[^}]*execution_simple/);
+  assert.ok(v2Match, "GSDModelConfigV2 should have execution_simple field");
+});
+
+test("preferences: budget profile sets execution_simple model", () => {
+  const budgetIdx = preferencesSrc.indexOf('case "budget":');
+  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+  const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
+  assert.ok(budgetBlock.includes("execution_simple:"), "budget profile should set execution_simple");
+});
+
+test("preferences: resolveModelWithFallbacksForUnit handles execute-task-simple", () => {
+  assert.ok(
+    preferencesSrc.includes('"execute-task-simple"'),
+    "should have execute-task-simple case in model resolution",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Classifier Module Structure
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("complexity: module exports classifyTaskComplexity function", () => {
+  assert.ok(
+    complexitySrc.includes("export function classifyTaskComplexity"),
+    "should export classifyTaskComplexity",
+  );
+});
+
+test("complexity: module exports TaskComplexity type", () => {
+  assert.ok(
+    complexitySrc.includes("export type TaskComplexity"),
+    "should export TaskComplexity type",
+  );
+});
+
+test("complexity: classifier uses conservative defaults", () => {
+  // Verify empty/missing input returns standard
+  assert.ok(
+    complexitySrc.includes('return "standard"'),
+    "should have standard as default return",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Unit Complexity Classification (from #579 — combined)
+// ═══════════════════════════════════════════════════════════════════════════
+
+const complexitySrcFull = readFileSync(join(__dirname, "..", "complexity.ts"), "utf-8");
+
+test("unit-classify: classifyUnitComplexity is exported", () => {
+  assert.ok(
+    complexitySrcFull.includes("export function classifyUnitComplexity"),
+    "should export classifyUnitComplexity",
+  );
+});
+
+test("unit-classify: unit type tier mapping exists", () => {
+  assert.ok(complexitySrcFull.includes("UNIT_TYPE_TIERS"), "should have unit type tier mapping");
+  assert.ok(complexitySrcFull.includes('"complete-slice": "light"'), "complete-slice should be light");
+  assert.ok(complexitySrcFull.includes('"replan-slice": "heavy"'), "replan-slice should be heavy");
+});
+
+test("unit-classify: hook units default to light", () => {
+  assert.ok(
+    complexitySrcFull.includes('startsWith("hook/")') && complexitySrcFull.includes('"light"'),
+    "hook units should default to light tier",
+  );
+});
+
+test("unit-classify: budget pressure has graduated thresholds", () => {
+  assert.ok(complexitySrcFull.includes("budgetPct >= 0.9"), "should have 90% threshold");
+  assert.ok(complexitySrcFull.includes("budgetPct >= 0.75"), "should have 75% threshold");
+  assert.ok(complexitySrcFull.includes("budgetPct < 0.5"), "should skip below 50%");
+});
+
+test("unit-classify: escalateTier function exists", () => {
+  assert.ok(
+    complexitySrcFull.includes("export function escalateTier"),
+    "should export escalateTier for failure recovery",
+  );
+});
+
+test("unit-classify: tierLabel function exists", () => {
+  assert.ok(
+    complexitySrcFull.includes("export function tierLabel"),
+    "should export tierLabel for dashboard display",
+  );
+});
+
+test("unit-classify: ComplexityTier imported from types.ts", () => {
+  assert.ok(
+    complexitySrcFull.includes('from "./types.js"') && complexitySrcFull.includes("ComplexityTier"),
+    "should import ComplexityTier from types",
+  );
+});