gsd-pi 2.16.0 → 2.18.0

package/dist/resources/extensions/gsd/queue-reorder-ui.ts

@@ -0,0 +1,263 @@
+/**
+ * GSD Queue Reorder UI
+ *
+ * Interactive TUI overlay for reordering pending milestones.
+ * ↑/↓ navigates cursor. Space grabs/releases item for moving.
+ * While grabbed, ↑/↓ swaps the item with its neighbor.
+ * Enter confirms all changes. Esc cancels.
+ * Conflicting depends_on entries are auto-removed on confirm.
+ */
+
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import { type Theme } from "@gsd/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, type TUI } from "@gsd/pi-tui";
+import { makeUI, GLYPH } from "../shared/ui.js";
+import { validateQueueOrder, type DependencyValidation } from "./queue-order.js";
+
+export interface ReorderItem {
+  id: string;
+  title: string;
+  dependsOn?: string[];
+}
+
+export interface ReorderResult {
+  order: string[];
+  /** depends_on entries to remove from CONTEXT.md files */
+  depsToRemove: Array<{ milestone: string; dep: string }>;
+}
+
+/**
+ * Show the queue reorder overlay.
+ * Returns the new order + deps to remove, or null if cancelled.
+ */
+export async function showQueueReorder(
+  ctx: ExtensionContext,
+  completed: ReorderItem[],
+  pending: ReorderItem[],
+): Promise<ReorderResult | null> {
+  if (!ctx.hasUI) return null;
+  if (pending.length < 2) return null;
+
+  return ctx.ui.custom<ReorderResult | null>((tui: TUI, theme: Theme, _kb, done) => {
+    const items = [...pending];
+    let cursor = 0;
+    let grabbed = false;
+    let cachedLines: string[] | undefined;
+    let validation: DependencyValidation;
+
+    // Mutable deps map — tracks removals during this session
+    const liveDeps = new Map<string, string[]>();
+    for (const item of [...completed, ...pending]) {
+      if (item.dependsOn && item.dependsOn.length > 0) {
+        liveDeps.set(item.id, [...item.dependsOn]);
+      }
+    }
+
+    const removedDeps: Array<{ milestone: string; dep: string }> = [];
+    const completedIds = new Set(completed.map(c => c.id));
+
+    function revalidate() {
+      validation = validateQueueOrder(items.map(i => i.id), liveDeps, completedIds);
+    }
+
+    revalidate();
+
+    function refresh() {
+      cachedLines = undefined;
+      tui.requestRender();
+    }
+
+    function swapItems(fromIdx: number, toIdx: number) {
+      if (toIdx < 0 || toIdx >= items.length) return;
+      const [item] = items.splice(fromIdx, 1);
+      items.splice(toIdx, 0, item);
+      cursor = toIdx;
+      revalidate();
+      refresh();
+    }
+
+    function removeDep(milestone: string, dep: string) {
+      const deps = liveDeps.get(milestone);
+      if (!deps) return;
+      const idx = deps.indexOf(dep);
+      if (idx >= 0) {
+        deps.splice(idx, 1);
+        if (deps.length === 0) liveDeps.delete(milestone);
+        removedDeps.push({ milestone, dep });
+        const item = items.find(i => i.id === milestone);
+        if (item?.dependsOn) {
+          item.dependsOn = item.dependsOn.filter(d => d !== dep);
+        }
+        revalidate();
+        refresh();
+      }
+    }
+
+    function handleInput(data: string) {
+      if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+        done(null);
+        return;
+      }
+
+      // Confirm — auto-resolve would_block violations
+      if (matchesKey(data, Key.enter)) {
+        const wouldBlock = validation.violations.filter(v => v.type === 'would_block');
+        for (const v of wouldBlock) {
+          removeDep(v.milestone, v.dependsOn);
+        }
+        done({ order: items.map(i => i.id), depsToRemove: removedDeps });
+        return;
+      }
+
+      // Space — toggle grab mode
+      if (data === " ") {
+        grabbed = !grabbed;
+        refresh();
+        return;
+      }
+
+      // ↑/↓ — move grabbed item OR navigate cursor
+      if (matchesKey(data, Key.up)) {
+        if (grabbed) {
+          swapItems(cursor, cursor - 1);
+        } else {
+          cursor = Math.max(0, cursor - 1);
+          refresh();
+        }
+        return;
+      }
+      if (matchesKey(data, Key.down)) {
+        if (grabbed) {
+          swapItems(cursor, cursor + 1);
+        } else {
+          cursor = Math.min(items.length - 1, cursor + 1);
+          refresh();
+        }
+        return;
+      }
+
+      // 'd' — manually remove a dep on the cursor item
+      if (data === "d" || data === "D") {
+        const item = items[cursor];
+        const deps = liveDeps.get(item.id);
+        if (deps) {
+          const activeDep = deps.find(d => !completedIds.has(d));
+          if (activeDep) removeDep(item.id, activeDep);
+        }
+        return;
+      }
+    }
+
+    function render(width: number): string[] {
+      if (cachedLines) return cachedLines;
+
+      const ui = makeUI(theme, width);
+      const lines: string[] = [];
+      const push = (...rows: string[][]) => { for (const r of rows) lines.push(...r); };
+      const add = (s: string) => truncateToWidth(s, width);
+
+      const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
+      push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
+
+      // Completed milestones (dimmed)
+      if (completed.length > 0) {
+        lines.push(add(theme.fg("dim", "  Completed:")));
+        for (const m of completed) {
+          const label = m.title && m.title !== m.id ? `${m.id}  ${m.title}` : m.id;
+          lines.push(add(`    ${theme.fg("dim", `${GLYPH.statusDone} ${label}`)}`));
+        }
+        push(ui.blank());
+      }
+
+      // Pending milestones
+      const queueLabel = grabbed ? "  Queue (space to release, ↑/↓ to move):" : "  Queue (space to grab, ↑/↓ to navigate):";
+      lines.push(add(theme.fg("text", queueLabel)));
+
+      const violatedPairs = new Set(
+        validation.violations.filter(v => v.type === 'would_block').map(v => `${v.milestone}:${v.dependsOn}`),
+      );
+      const redundantPairs = new Set(
+        validation.redundant.map(r => `${r.milestone}:${r.dependsOn}`),
+      );
+
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const isCursor = i === cursor;
+        const num = i + 1;
+        const label = item.title && item.title !== item.id ? `${item.id}  ${item.title}` : item.id;
+
+        if (isCursor && grabbed) {
+          lines.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
+        } else if (isCursor) {
+          lines.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
+        } else {
+          lines.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
+        }
+
+        // depends_on annotations
+        const deps = liveDeps.get(item.id) ?? [];
+        for (const dep of deps) {
+          if (completedIds.has(dep)) continue;
+          const pairKey = `${item.id}:${dep}`;
+          if (violatedPairs.has(pairKey)) {
+            lines.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
+          } else if (redundantPairs.has(pairKey)) {
+            lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
+          } else {
+            lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
+          }
+        }
+
+        // Missing deps
+        for (const v of validation.violations.filter(v => v.milestone === item.id && v.type === 'missing_dep')) {
+          lines.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
+        }
+      }
+
+      // Removed deps feedback
+      if (removedDeps.length > 0) {
+        push(ui.blank());
+        for (const r of removedDeps) {
+          lines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
+        }
+      }
+
+      // Circular warning
+      const circ = validation.violations.find(v => v.type === 'circular');
+      if (circ) {
+        push(ui.blank());
+        lines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
+      }
+
+      push(ui.blank());
+
+      // Hints — context-sensitive based on grab state
+      const hints: string[] = [];
+      if (grabbed) {
+        hints.push("↑/↓ move item", "space release");
+      } else {
+        hints.push("↑/↓ navigate", "space grab");
+      }
+      const hasDeps = liveDeps.get(items[cursor]?.id)?.some(d => !completedIds.has(d));
+      if (hasDeps) hints.push("d del dep");
+
+      const wouldBlockCount = validation.violations.filter(v => v.type === 'would_block').length;
+      if (wouldBlockCount > 0) {
+        hints.push(`enter (fixes ${wouldBlockCount} dep)`);
+      } else {
+        hints.push("enter ok");
+      }
+      hints.push("esc");
+
+      push(ui.hints(hints), ui.bar());
+
+      cachedLines = lines;
+      return lines;
+    }
+
+    return { render, invalidate: () => { cachedLines = undefined; }, handleInput };
+  }, {
+    overlay: true,
+    overlayOptions: { width: "70%", minWidth: 50, maxHeight: "80%", anchor: "center" },
+  });
+}

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/state.ts

@@ -224,9 +224,21 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
           const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
           if (draftFile) activeMilestoneHasDraft = true;
         }
-        activeMilestone = { id: mid, title: mid };
-        activeMilestoneFound = true;
-        registry.push({ id: mid, title: mid, status: 'active' });
+
+        // Check milestone-level dependencies before promoting to active.
+        // Without this, a queued milestone with depends_on in its CONTEXT
+        // frontmatter would be promoted to active even when its deps are unmet
+        // (the dep check only existed in the has-roadmap path previously).
+        const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
+        const deps = parseContextDependsOn(contextContent);
+        const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
+        if (depsUnmet) {
+          registry.push({ id: mid, title: mid, status: 'pending', dependsOn: deps });
+        } else {
+          activeMilestone = { id: mid, title: mid };
+          activeMilestoneFound = true;
+          registry.push({ id: mid, title: mid, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+        }
       } else {
         registry.push({ id: mid, title: mid, status: 'pending' });
       }

package/dist/resources/extensions/gsd/templates/knowledge.md

@@ -0,0 +1,19 @@
+# Project Knowledge
+
+Append-only register of project-specific rules, patterns, and lessons learned.
+Agents read this before every unit. Add entries when you discover something worth remembering.
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|

package/dist/resources/extensions/gsd/templates/preferences.md

@@ -15,7 +15,21 @@ git:
   snapshots:
   pre_merge_check:
   commit_type:
+  main_branch:
+  merge_strategy:
+  isolation:
 unique_milestone_ids:
+budget_ceiling:
+budget_enforcement:
+context_pause_threshold:
+notifications:
+  enabled:
+  on_complete:
+  on_error:
+  on_budget:
+  on_milestone:
+  on_attention:
+uat_dispatch:
 ---
 
 # GSD Skill Preferences

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);
+  }
+});