gsd-pi 2.17.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/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-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/dist/resources/extensions/gsd/tests/derive-state-deps.test.ts

@@ -303,6 +303,105 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── Test Group 7: unique-id-deps ──────────────────────────────────────
+  // M004-0zjrg0 is complete, M005-b0m2hl depends_on M004-0zjrg0 → M005 should activate.
+  // Regression: parseContextDependsOn() used .toUpperCase(), converting "M004-0zjrg0"
+  // to "M004-0ZJRG0", breaking the case-sensitive lookup in completeMilestoneIds.
+  console.log('\n=== unique-id-deps: unique milestone IDs with lowercase hex suffix ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M004-0zjrg0: complete (all slices done + SUMMARY present)
+      writeRoadmap(base, 'M004-0zjrg0', `# M004-0zjrg0: First Unique Milestone
+
+**Vision:** Complete milestone with unique ID.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeMilestoneSummary(base, 'M004-0zjrg0', '# M004-0zjrg0 Summary\n\nComplete.');
+
+      // M005-b0m2hl: depends on M004-0zjrg0 (lowercase hex suffix)
+      writeContext(base, 'M005-b0m2hl', 'depends_on: [M004-0zjrg0]');
+
+      const state = await deriveState(base);
+
+      assertEq(state.registry.find(e => e.id === 'M004-0zjrg0')?.status, 'complete',
+        'unique-id-deps: M004-0zjrg0 is complete');
+      assertEq(state.registry.find(e => e.id === 'M005-b0m2hl')?.status, 'active',
+        'unique-id-deps: M005-b0m2hl is active (dep on M004-0zjrg0 met)');
+      assertEq(state.activeMilestone?.id, 'M005-b0m2hl',
+        'unique-id-deps: activeMilestone is M005-b0m2hl');
+      assertTrue(state.phase !== 'blocked',
+        'unique-id-deps: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 8: unique-id-deps-blocked ─────────────────────────────
+  // M004-0zjrg0 is NOT complete, M005-b0m2hl depends_on M004-0zjrg0 → M005 should be pending
+  console.log('\n=== unique-id-deps-blocked: unique ID dep not yet met ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M004-0zjrg0: incomplete (slice not done)
+      writeRoadmap(base, 'M004-0zjrg0', `# M004-0zjrg0: Incomplete Unique Milestone
+
+**Vision:** Still in progress.
+
+## Slices
+
+- [ ] **S01: In Progress** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeSlicePlan(base, 'M004-0zjrg0', 'S01', `# S01: In Progress
+
+**Goal:** Test dep blocking with unique IDs.
+
+## Tasks
+
+- [ ] **T01: Work** \`est:15m\`
+  Still doing work.
+`);
+
+      // M005-b0m2hl: depends on M004-0zjrg0 (still incomplete)
+      writeContext(base, 'M005-b0m2hl', 'depends_on: [M004-0zjrg0]');
+
+      const state = await deriveState(base);
+
+      assertEq(state.activeMilestone?.id, 'M004-0zjrg0',
+        'unique-id-deps-blocked: activeMilestone is M004-0zjrg0');
+      assertEq(state.registry.find(e => e.id === 'M005-b0m2hl')?.status, 'pending',
+        'unique-id-deps-blocked: M005-b0m2hl is pending (dep not met)');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 9: parseContextDependsOn preserves case ───────────────
+  // Direct unit test: verify the parsed dep ID matches the input exactly
+  console.log('\n=== parseContextDependsOn: preserves case of unique IDs ===');
+  {
+    const { parseContextDependsOn } = await import('../files.ts');
+
+    const deps1 = parseContextDependsOn('---\ndepends_on: [M004-0zjrg0]\n---\n');
+    assertEq(deps1[0], 'M004-0zjrg0',
+      'parseContextDependsOn preserves lowercase hex suffix');
+
+    const deps2 = parseContextDependsOn('---\ndepends_on: [M001, M004-abc123]\n---\n');
+    assertEq(deps2[0], 'M001', 'preserves classic uppercase ID');
+    assertEq(deps2[1], 'M004-abc123', 'preserves mixed-case unique ID');
+
+    const deps3 = parseContextDependsOn('---\ndepends_on: []\n---\n');
+    assertEq(deps3.length, 0, 'empty deps returns empty array');
+
+    const deps4 = parseContextDependsOn(null);
+    assertEq(deps4.length, 0, 'null content returns empty array');
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/in-flight-tool-tracking.test.ts

@@ -0,0 +1,79 @@
+/**
+ * In-flight tool tracking tests — verifies that markToolStart/markToolEnd
+ * correctly manage the in-flight tools set used by the idle watchdog to
+ * distinguish "agent waiting on long-running tool" from "agent is idle".
+ *
+ * Background: The idle watchdog checks every 15s for agent progress. Without
+ * in-flight tool tracking, agents waiting on await_job or async_bash (which
+ * can run 20+ minutes for evaluations, deployments, test suites) are falsely
+ * declared idle and interrupted by recovery steering messages.
+ *
+ * The fix hooks tool_execution_start/end events to track active tool calls.
+ * When tools are in-flight, the watchdog resets lastProgressAt instead of
+ * triggering idle recovery.
+ */
+
+import { markToolStart, markToolEnd, isAutoActive } from "../auto.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══ markToolStart / markToolEnd basic behavior ═════════════════════════════
+
+{
+  console.log("\n=== markToolStart: no-op when auto-mode is not active ===");
+  // When auto-mode is not active, markToolStart should silently ignore
+  // (the guard `if (!active) return` prevents set pollution outside auto-mode)
+  assertTrue(!isAutoActive(), "auto-mode should not be active in tests");
+  markToolStart("tool-1");
+  // We can't directly inspect the set, but markToolEnd should be a safe no-op
+  markToolEnd("tool-1");
+  // If we got here without error, the guard works
+  assertTrue(true, "markToolStart/markToolEnd are safe no-ops when inactive");
+}
+
+{
+  console.log("\n=== markToolEnd: no-op for unknown toolCallId ===");
+  // Set.delete on non-existent key is a no-op — verify no crash
+  markToolEnd("nonexistent-tool-call-id");
+  assertTrue(true, "markToolEnd handles unknown IDs gracefully");
+}
+
+{
+  console.log("\n=== markToolEnd: idempotent — double-end does not crash ===");
+  markToolEnd("some-id");
+  markToolEnd("some-id");
+  assertTrue(true, "double markToolEnd is safe");
+}
+
+// ═══ Integration contract: expected exports from auto.ts ═════════════════════
+
+{
+  console.log("\n=== auto.ts exports markToolStart and markToolEnd ===");
+  assertEq(typeof markToolStart, "function", "markToolStart should be a function");
+  assertEq(typeof markToolEnd, "function", "markToolEnd should be a function");
+}
+
+{
+  console.log("\n=== markToolStart accepts string toolCallId ===");
+  // Verify the function signature handles string input without error
+  // (when inactive, this is a no-op but should not throw)
+  try {
+    markToolStart("toolu_01ABC123");
+    assertTrue(true, "accepts standard Claude tool call ID format");
+  } catch (e) {
+    assertTrue(false, `should not throw: ${e}`);
+  }
+}
+
+{
+  console.log("\n=== markToolEnd accepts string toolCallId ===");
+  try {
+    markToolEnd("toolu_01ABC123");
+    assertTrue(true, "accepts standard Claude tool call ID format");
+  } catch (e) {
+    assertTrue(false, `should not throw: ${e}`);
+  }
+}
+
+report();