gsd-pi 2.16.0 → 2.17.0

package/dist/resources/extensions/gsd/preferences.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { getAgentDir } from "@gsd/pi-coding-agent";
 import type { GitPreferences } from "./git-service.js";
-import type { PostUnitHookConfig, PreDispatchHookConfig, BudgetEnforcementMode, NotificationPreferences } from "./types.js";
+import type { PostUnitHookConfig, PreDispatchHookConfig, BudgetEnforcementMode, NotificationPreferences, TokenProfile, InlineLevel, PhaseSkipPreferences } from "./types.js";
 import { VALID_BRANCH_NAME } from "./git-service.js";
 
 const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
@@ -36,6 +36,8 @@ const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "git",
   "post_unit_hooks",
   "pre_dispatch_hooks",
+  "token_profile",
+  "phases",
 ]);
 
 export interface GSDSkillRule {
@@ -66,7 +68,9 @@ export interface GSDModelConfig {
   research?: string;
   planning?: string;
   execution?: string;
+  execution_simple?: string;
   completion?: string;
+  subagent?: string;
 }
 
 /**
@@ -77,7 +81,9 @@ export interface GSDModelConfigV2 {
   research?: string | GSDPhaseModelConfig;
   planning?: string | GSDPhaseModelConfig;
   execution?: string | GSDPhaseModelConfig;
+  execution_simple?: string | GSDPhaseModelConfig;
   completion?: string | GSDPhaseModelConfig;
+  subagent?: string | GSDPhaseModelConfig;
 }
 
 /** Normalized model selection with resolved fallbacks */
@@ -122,6 +128,8 @@ export interface GSDPreferences {
   git?: GitPreferences;
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
+  token_profile?: TokenProfile;
+  phases?: PhaseSkipPreferences;
 }
 
 export interface LoadedGSDPreferences {
@@ -631,11 +639,19 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
     case "execute-task":
       phaseConfig = m.execution;
       break;
+    case "execute-task-simple":
+      phaseConfig = m.execution_simple ?? m.execution;
+      break;
     case "complete-slice":
     case "run-uat":
       phaseConfig = m.completion;
       break;
     default:
+      // Subagent unit types (e.g., "subagent", "subagent/scout")
+      if (unitType === "subagent" || unitType.startsWith("subagent/")) {
+        phaseConfig = m.subagent;
+        break;
+      }
       return undefined;
   }
 
@@ -670,6 +686,73 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
   };
 }
 
+// ─── Token Profile Resolution ─────────────────────────────────────────────
+
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+
+/**
+ * Resolve profile defaults for a given token profile tier.
+ * Returns a partial GSDPreferences that is used as the base layer —
+ * explicit user preferences always override these defaults.
+ */
+export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPreferences> {
+  switch (profile) {
+    case "budget":
+      return {
+        models: {
+          planning: "claude-sonnet-4-5-20250514",
+          execution: "claude-sonnet-4-5-20250514",
+          execution_simple: "claude-haiku-4-5-20250414",
+          completion: "claude-haiku-4-5-20250414",
+          subagent: "claude-haiku-4-5-20250414",
+        },
+        phases: {
+          skip_research: true,
+          skip_reassess: true,
+          skip_slice_research: true,
+        },
+      };
+    case "balanced":
+      return {
+        models: {
+          subagent: "claude-sonnet-4-5-20250514",
+        },
+        phases: {
+          skip_slice_research: true,
+        },
+      };
+    case "quality":
+      return {
+        models: {},
+        phases: {},
+      };
+  }
+}
+
+/**
+ * Resolve the effective token profile from preferences.
+ * Returns "balanced" when no profile is set (D046).
+ */
+export function resolveEffectiveProfile(): TokenProfile {
+  const prefs = loadEffectiveGSDPreferences();
+  const profile = prefs?.preferences.token_profile;
+  if (profile && VALID_TOKEN_PROFILES.has(profile)) return profile;
+  return "balanced";
+}
+
+/**
+ * Resolve the inline level from the active token profile.
+ * budget → minimal, balanced → standard, quality → full.
+ */
+export function resolveInlineLevel(): InlineLevel {
+  const profile = resolveEffectiveProfile();
+  switch (profile) {
+    case "budget": return "minimal";
+    case "balanced": return "standard";
+    case "quality": return "full";
+  }
+}
+
 function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPreferences {
   return {
     version: override.version ?? base.version,
@@ -697,6 +780,10 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
       : undefined,
     post_unit_hooks: mergePostUnitHooks(base.post_unit_hooks, override.post_unit_hooks),
     pre_dispatch_hooks: mergePreDispatchHooks(base.pre_dispatch_hooks, override.pre_dispatch_hooks),
+    token_profile: override.token_profile ?? base.token_profile,
+    phases: (base.phases || override.phases)
+      ? { ...(base.phases ?? {}), ...(override.phases ?? {}) }
+      : undefined,
   };
 }
 
@@ -803,6 +890,36 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Token Profile ─────────────────────────────────────────────────
+  if (preferences.token_profile !== undefined) {
+    if (typeof preferences.token_profile === "string" && VALID_TOKEN_PROFILES.has(preferences.token_profile as TokenProfile)) {
+      validated.token_profile = preferences.token_profile as TokenProfile;
+    } else {
+      errors.push(`token_profile must be one of: budget, balanced, quality`);
+    }
+  }
+
+  // ─── Phase Skip Preferences ─────────────────────────────────────────
+  if (preferences.phases !== undefined) {
+    if (typeof preferences.phases === "object" && preferences.phases !== null) {
+      const validatedPhases: PhaseSkipPreferences = {};
+      const p = preferences.phases as Record<string, unknown>;
+      if (p.skip_research !== undefined) validatedPhases.skip_research = !!p.skip_research;
+      if (p.skip_reassess !== undefined) validatedPhases.skip_reassess = !!p.skip_reassess;
+      if (p.skip_slice_research !== undefined) validatedPhases.skip_slice_research = !!p.skip_slice_research;
+      // Warn on unknown phase keys
+      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research"]);
+      for (const key of Object.keys(p)) {
+        if (!knownPhaseKeys.has(key)) {
+          warnings.push(`unknown phases key "${key}" — ignored`);
+        }
+      }
+      validated.phases = validatedPhases;
+    } else {
+      errors.push(`phases must be an object`);
+    }
+  }
+
   // ─── Context Pause Threshold ────────────────────────────────────────
   if (preferences.context_pause_threshold !== undefined) {
     const raw = preferences.context_pause_threshold;
@@ -1046,6 +1163,10 @@ export function validatePreferences(preferences: GSDPreferences): {
         errors.push("git.isolation must be one of: worktree, branch");
       }
     }
+    if (g.commit_docs !== undefined) {
+      if (typeof g.commit_docs === "boolean") git.commit_docs = g.commit_docs;
+      else errors.push("git.commit_docs must be a boolean");
+    }
     // Deprecated: merge_to_main is ignored (branchless architecture).
     if (g.merge_to_main !== undefined) {
       warnings.push("git.merge_to_main is deprecated — milestone-level merge is now always used. Remove this setting.");

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

@@ -0,0 +1,290 @@
+// GSD Extension — Routing History (Adaptive Learning)
+// Tracks success/failure per tier per unit-type pattern to improve
+// classification accuracy over time.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import type { ComplexityTier } from "./types.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TierOutcome {
+  success: number;
+  fail: number;
+}
+
+export interface PatternHistory {
+  light: TierOutcome;
+  standard: TierOutcome;
+  heavy: TierOutcome;
+}
+
+export interface RoutingHistoryData {
+  version: 1;
+  /** Keyed by pattern string, e.g. "execute-task:docs" or "complete-slice" */
+  patterns: Record<string, PatternHistory>;
+  /** User feedback entries (from /gsd:rate-unit) */
+  feedback: FeedbackEntry[];
+  /** Last updated timestamp */
+  updatedAt: string;
+}
+
+export interface FeedbackEntry {
+  unitType: string;
+  unitId: string;
+  tier: ComplexityTier;
+  rating: "over" | "under" | "ok";
+  timestamp: string;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const HISTORY_FILE = "routing-history.json";
+const ROLLING_WINDOW = 50;        // only consider last N entries per pattern
+const FAILURE_THRESHOLD = 0.20;   // >20% failure rate triggers tier bump
+const FEEDBACK_WEIGHT = 2;        // feedback signals count 2x vs automatic
+
+// ─── In-Memory State ─────────────────────────────────────────────────────────
+
+let history: RoutingHistoryData | null = null;
+let historyBasePath = "";
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Initialize routing history for a project.
+ */
+export function initRoutingHistory(base: string): void {
+  historyBasePath = base;
+  history = loadHistory(base);
+}
+
+/**
+ * Reset routing history state.
+ */
+export function resetRoutingHistory(): void {
+  history = null;
+  historyBasePath = "";
+}
+
+/**
+ * Record the outcome of a unit dispatch.
+ *
+ * @param unitType  The unit type (e.g. "execute-task")
+ * @param tier      The tier that was used
+ * @param success   Whether the unit completed successfully
+ * @param tags      Optional tags from task metadata (e.g. ["docs", "test"])
+ */
+export function recordOutcome(
+  unitType: string,
+  tier: ComplexityTier,
+  success: boolean,
+  tags?: string[],
+): void {
+  if (!history) return;
+
+  // Record for the base unit type
+  const basePattern = unitType;
+  ensurePattern(basePattern);
+  const outcome = history.patterns[basePattern][tier];
+  if (success) outcome.success++;
+  else outcome.fail++;
+
+  // Record for tag-specific patterns (e.g. "execute-task:docs")
+  if (tags && tags.length > 0) {
+    for (const tag of tags) {
+      const tagPattern = `${unitType}:${tag}`;
+      ensurePattern(tagPattern);
+      const tagOutcome = history.patterns[tagPattern][tier];
+      if (success) tagOutcome.success++;
+      else tagOutcome.fail++;
+    }
+  }
+
+  // Apply rolling window — cap total entries per tier per pattern
+  for (const pattern of Object.keys(history.patterns)) {
+    const p = history.patterns[pattern];
+    for (const t of ["light", "standard", "heavy"] as const) {
+      const total = p[t].success + p[t].fail;
+      if (total > ROLLING_WINDOW) {
+        const scale = ROLLING_WINDOW / total;
+        p[t].success = Math.round(p[t].success * scale);
+        p[t].fail = Math.round(p[t].fail * scale);
+      }
+    }
+  }
+
+  history.updatedAt = new Date().toISOString();
+  saveHistory(historyBasePath, history);
+}
+
+/**
+ * Record user feedback for the last completed unit.
+ */
+export function recordFeedback(
+  unitType: string,
+  unitId: string,
+  tier: ComplexityTier,
+  rating: "over" | "under" | "ok",
+): void {
+  if (!history) return;
+
+  history.feedback.push({
+    unitType,
+    unitId,
+    tier,
+    rating,
+    timestamp: new Date().toISOString(),
+  });
+
+  // Cap feedback array at 200 entries
+  if (history.feedback.length > 200) {
+    history.feedback = history.feedback.slice(-200);
+  }
+
+  // Apply feedback as weighted outcome
+  const pattern = unitType;
+  ensurePattern(pattern);
+
+  if (rating === "over") {
+    // User says this could have used a simpler model → record as success at current tier
+    // and also as success at one tier lower (encourages more downgrading)
+    const lower = tierBelow(tier);
+    if (lower) {
+      const outcomes = history.patterns[pattern][lower];
+      outcomes.success += FEEDBACK_WEIGHT;
+    }
+  } else if (rating === "under") {
+    // User says this needed a better model → record as failure at current tier
+    const outcomes = history.patterns[pattern][tier];
+    outcomes.fail += FEEDBACK_WEIGHT;
+  }
+  // "ok" = no adjustment needed
+
+  history.updatedAt = new Date().toISOString();
+  saveHistory(historyBasePath, history);
+}
+
+/**
+ * Get the recommended tier adjustment for a given pattern.
+ * Returns the tier to bump to if the failure rate exceeds threshold,
+ * or null if no adjustment is needed.
+ */
+export function getAdaptiveTierAdjustment(
+  unitType: string,
+  currentTier: ComplexityTier,
+  tags?: string[],
+): ComplexityTier | null {
+  if (!history) return null;
+
+  // Check tag-specific patterns first (more specific)
+  if (tags && tags.length > 0) {
+    for (const tag of tags) {
+      const tagPattern = `${unitType}:${tag}`;
+      const adjustment = checkPatternFailureRate(tagPattern, currentTier);
+      if (adjustment) return adjustment;
+    }
+  }
+
+  // Fall back to base pattern
+  return checkPatternFailureRate(unitType, currentTier);
+}
+
+/**
+ * Clear all routing history (user-triggered reset).
+ */
+export function clearRoutingHistory(base: string): void {
+  history = createEmptyHistory();
+  saveHistory(base, history);
+}
+
+/**
+ * Get current history data (for display/debugging).
+ */
+export function getRoutingHistory(): RoutingHistoryData | null {
+  return history;
+}
+
+// ─── Internal ────────────────────────────────────────────────────────────────
+
+function checkPatternFailureRate(
+  pattern: string,
+  tier: ComplexityTier,
+): ComplexityTier | null {
+  if (!history?.patterns[pattern]) return null;
+
+  const outcomes = history.patterns[pattern][tier];
+  const total = outcomes.success + outcomes.fail;
+  if (total < 3) return null; // Not enough data
+
+  const failureRate = outcomes.fail / total;
+  if (failureRate > FAILURE_THRESHOLD) {
+    // Bump to next tier
+    return tierAbove(tier);
+  }
+
+  return null;
+}
+
+function tierAbove(tier: ComplexityTier): ComplexityTier | null {
+  switch (tier) {
+    case "light": return "standard";
+    case "standard": return "heavy";
+    case "heavy": return null;
+  }
+}
+
+function tierBelow(tier: ComplexityTier): ComplexityTier | null {
+  switch (tier) {
+    case "light": return null;
+    case "standard": return "light";
+    case "heavy": return "standard";
+  }
+}
+
+function ensurePattern(pattern: string): void {
+  if (!history) return;
+  if (!history.patterns[pattern]) {
+    history.patterns[pattern] = {
+      light: { success: 0, fail: 0 },
+      standard: { success: 0, fail: 0 },
+      heavy: { success: 0, fail: 0 },
+    };
+  }
+}
+
+function createEmptyHistory(): RoutingHistoryData {
+  return {
+    version: 1,
+    patterns: {},
+    feedback: [],
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function historyPath(base: string): string {
+  return join(gsdRoot(base), HISTORY_FILE);
+}
+
+function loadHistory(base: string): RoutingHistoryData {
+  try {
+    const raw = readFileSync(historyPath(base), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 1 && parsed.patterns) {
+      return parsed as RoutingHistoryData;
+    }
+  } catch {
+    // File doesn't exist or is corrupt — start fresh
+  }
+  return createEmptyHistory();
+}
+
+function saveHistory(base: string, data: RoutingHistoryData): void {
+  try {
+    mkdirSync(gsdRoot(base), { recursive: true });
+    writeFileSync(historyPath(base), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  } catch {
+    // Non-fatal — don't let history failures break auto-mode
+  }
+}

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

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 
 import {
   resolveExpectedArtifactPath,
+  verifyExpectedArtifact,
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
   completedKeysPath,
@@ -14,6 +15,7 @@ import {
   removePersistedKey,
   loadPersistedKeys,
 } from "../auto-recovery.ts";
+import { parseRoadmap, clearParseCache } from "../files.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -270,3 +272,51 @@ test("removePersistedKey is safe when file doesn't exist", () => {
     cleanup(base);
   }
 });
+
+// ─── verifyExpectedArtifact: parse cache collision regression ─────────────
+
+test("verifyExpectedArtifact detects roadmap [x] change despite parse cache", () => {
+  // Regression test: cacheKey collision when [ ] → [x] doesn't change
+  // file length or first/last 100 chars. Without the fix, parseRoadmap
+  // returns stale cached data with done=false even though the file has [x].
+  const base = makeTmpBase();
+  try {
+    // Build a roadmap long enough that the [x] change is outside the first/last 100 chars
+    const padding = "A".repeat(200);
+    const roadmapBefore = [
+      `# M001: Test Milestone ${padding}`,
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low`",
+      "",
+      `## Footer ${padding}`,
+    ].join("\n");
+    const roadmapAfter = roadmapBefore.replace("- [ ] **S01:", "- [x] **S01:");
+
+    // Verify lengths are identical (the key collision condition)
+    assert.equal(roadmapBefore.length, roadmapAfter.length);
+
+    // Populate parse cache with the pre-edit roadmap
+    const before = parseRoadmap(roadmapBefore);
+    const sliceBefore = before.slices.find(s => s.id === "S01");
+    assert.ok(sliceBefore);
+    assert.equal(sliceBefore!.done, false);
+
+    // Now write the post-edit roadmap to disk and create required artifacts
+    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    writeFileSync(roadmapPath, roadmapAfter);
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    writeFileSync(summaryPath, "# Summary\nDone.");
+    const uatPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
+    writeFileSync(uatPath, "# UAT\nPassed.");
+
+    // verifyExpectedArtifact should see the [x] despite the parse cache
+    // having the [ ] version. The fix clears the parse cache inside verify.
+    const verified = verifyExpectedArtifact("complete-slice", "M001/S01", base);
+    assert.equal(verified, true, "verifyExpectedArtifact should return true when roadmap has [x]");
+  } finally {
+    clearParseCache();
+    cleanup(base);
+  }
+});