gsd-pi 2.17.0 → 2.19.0

package/src/resources/extensions/gsd/prompts/triage-captures.md

@@ -0,0 +1,62 @@
+You are triaging user-captured thoughts during a GSD session.
+
+## UNIT: Triage Captures
+
+The user captured thoughts during execution using `/gsd capture`. Your job is to classify each capture, present your proposals, get user confirmation, and update CAPTURES.md with the final classifications.
+
+## Pending Captures
+
+{{pendingCaptures}}
+
+## Current Slice Plan
+
+{{currentPlan}}
+
+## Current Roadmap
+
+{{roadmapContext}}
+
+## Classification Criteria
+
+For each capture, classify it as one of:
+
+- **quick-task**: Small, self-contained, no downstream impact. Can be done in minutes without modifying the plan. Examples: fix a typo, add a missing import, tweak a config value.
+- **inject**: Belongs in the current slice but wasn't planned. Needs a new task added to the slice plan. Examples: add error handling to a module being built, add a missing test case for current work.
+- **defer**: Belongs in a future slice or milestone. Not urgent for current work. Examples: performance optimization, feature that depends on unbuilt infrastructure, nice-to-have enhancement.
+- **replan**: Changes the shape of remaining work in the current slice. Existing incomplete tasks may need rewriting. Examples: "the approach is wrong, we need to use X instead of Y", discovering a fundamental constraint.
+- **note**: Informational only. No action needed right now. Good context for future reference. Examples: "remember that the API has a rate limit", observations about code quality.
+
+## Decision Guidelines
+
+- Prefer **quick-task** when the work is clearly small and self-contained.
+- Prefer **inject** over **replan** when only a new task is needed, not rewriting existing ones.
+- Prefer **defer** over **inject** when the work doesn't belong in the current slice's scope.
+- Use **replan** only when remaining incomplete tasks need to change — not just for adding work.
+- Use **note** for observations that don't require action.
+- When unsure between quick-task and inject, consider: will this take more than 10 minutes? If yes, inject.
+
+## Instructions
+
+1. **Classify** each pending capture using the criteria above.
+
+2. **Present** your classifications to the user using `ask_user_questions`. For each capture, show:
+   - The capture text
+   - Your proposed classification
+   - Your rationale
+   - If applicable, which files would be affected
+   
+   For captures classified as **note** or **defer**, auto-confirm without asking — these are low-impact.
+   For captures classified as **quick-task**, **inject**, or **replan**, ask the user to confirm or choose a different classification.
+
+3. **Update** `.gsd/CAPTURES.md` — for each capture, update its section with the confirmed classification:
+   - Change `**Status:** pending` to `**Status:** resolved`
+   - Add `**Classification:** <type>`
+   - Add `**Resolution:** <brief description of what will happen>`
+   - Add `**Rationale:** <why this classification>`
+   - Add `**Resolved:** <current ISO timestamp>`
+
+4. **Summarize** what was triaged: how many captures, what classifications were assigned, and what actions are pending (e.g., "2 quick-tasks ready for execution, 1 deferred to S03").
+
+**Important:** Do NOT execute any resolutions. Only classify and update CAPTURES.md. Resolution execution happens separately (in auto-mode dispatch or manually by the user).
+
+When done, say: "Triage complete."

package/src/resources/extensions/gsd/queue-order.ts

@@ -0,0 +1,231 @@
+/**
+ * GSD Queue Order — Custom milestone execution ordering.
+ *
+ * Stores an explicit execution order in `.gsd/QUEUE-ORDER.json`.
+ * When present, `findMilestoneIds()` uses this order instead of
+ * the default numeric sort (milestoneIdSort).
+ *
+ * The file is committed to git (not gitignored) so ordering
+ * survives branch switches and is shared across sessions.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { milestoneIdSort } from "./guided-flow.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface QueueOrderFile {
+  order: string[];
+  updatedAt: string;
+}
+
+export interface DependencyViolation {
+  milestone: string;
+  dependsOn: string;
+  type: 'would_block' | 'circular' | 'missing_dep';
+  message: string;
+}
+
+export interface DependencyRedundancy {
+  milestone: string;
+  dependsOn: string;
+}
+
+export interface DependencyValidation {
+  valid: boolean;
+  violations: DependencyViolation[];
+  redundant: DependencyRedundancy[];
+}
+
+// ─── Path ────────────────────────────────────────────────────────────────────
+
+function queueOrderPath(basePath: string): string {
+  return join(gsdRoot(basePath), "QUEUE-ORDER.json");
+}
+
+// ─── Read / Write ────────────────────────────────────────────────────────────
+
+/**
+ * Load the custom queue order. Returns null if no file exists or if
+ * the file is corrupt/unreadable.
+ */
+export function loadQueueOrder(basePath: string): string[] | null {
+  const p = queueOrderPath(basePath);
+  if (!existsSync(p)) return null;
+  try {
+    const data: QueueOrderFile = JSON.parse(readFileSync(p, "utf-8"));
+    if (!Array.isArray(data.order)) return null;
+    return data.order;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save a custom queue order to disk.
+ */
+export function saveQueueOrder(basePath: string, order: string[]): void {
+  const data: QueueOrderFile = {
+    order,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(queueOrderPath(basePath), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// ─── Sorting ─────────────────────────────────────────────────────────────────
+
+/**
+ * Sort milestone IDs respecting a custom order.
+ *
+ * - IDs present in `customOrder` appear in that exact sequence.
+ * - IDs on disk but NOT in `customOrder` are appended at the end,
+ *   sorted by the default `milestoneIdSort` (numeric).
+ * - IDs in `customOrder` but NOT on disk are silently skipped.
+ * - When `customOrder` is null, falls back to `milestoneIdSort`.
+ */
+export function sortByQueueOrder(ids: string[], customOrder: string[] | null): string[] {
+  if (!customOrder) return [...ids].sort(milestoneIdSort);
+
+  const idSet = new Set(ids);
+  const ordered: string[] = [];
+
+  // First: IDs from customOrder that exist on disk
+  for (const id of customOrder) {
+    if (idSet.has(id)) {
+      ordered.push(id);
+      idSet.delete(id);
+    }
+  }
+
+  // Then: remaining IDs not in customOrder, in default sort order
+  const remaining = [...idSet].sort(milestoneIdSort);
+  return [...ordered, ...remaining];
+}
+
+// ─── Pruning ─────────────────────────────────────────────────────────────────
+
+/**
+ * Remove IDs from the queue order file that are no longer valid
+ * (completed or deleted milestones). No-op if file doesn't exist.
+ */
+export function pruneQueueOrder(basePath: string, validIds: string[]): void {
+  const order = loadQueueOrder(basePath);
+  if (!order) return;
+
+  const validSet = new Set(validIds);
+  const pruned = order.filter(id => validSet.has(id));
+
+  if (pruned.length !== order.length) {
+    saveQueueOrder(basePath, pruned);
+  }
+}
+
+// ─── Validation ──────────────────────────────────────────────────────────────
+
+/**
+ * Validate a proposed queue order against dependency constraints.
+ *
+ * Checks:
+ * - would_block: A milestone is placed before one of its dependencies
+ * - circular: Two or more milestones form a dependency cycle
+ * - missing_dep: A milestone depends on an ID that doesn't exist
+ * - redundant: A dependency is satisfied by queue position (dep comes earlier)
+ */
+export function validateQueueOrder(
+  order: string[],
+  depsMap: Map<string, string[]>,
+  completedIds: Set<string>,
+): DependencyValidation {
+  const violations: DependencyViolation[] = [];
+  const redundant: DependencyRedundancy[] = [];
+
+  const positionMap = new Map<string, number>();
+  for (let i = 0; i < order.length; i++) {
+    positionMap.set(order[i], i);
+  }
+
+  const allKnownIds = new Set([...order, ...completedIds]);
+
+  for (const [mid, deps] of depsMap) {
+    const midPos = positionMap.get(mid);
+    if (midPos === undefined) continue; // not in pending order
+
+    for (const dep of deps) {
+      // Dep already completed — always satisfied
+      if (completedIds.has(dep)) continue;
+
+      // Dep doesn't exist anywhere
+      if (!allKnownIds.has(dep)) {
+        violations.push({
+          milestone: mid,
+          dependsOn: dep,
+          type: 'missing_dep',
+          message: `${mid} depends on ${dep}, but ${dep} does not exist.`,
+        });
+        continue;
+      }
+
+      const depPos = positionMap.get(dep);
+      if (depPos === undefined) continue; // dep not in pending order (edge case)
+
+      if (depPos > midPos) {
+        // Dep comes AFTER this milestone in the order — violation
+        violations.push({
+          milestone: mid,
+          dependsOn: dep,
+          type: 'would_block',
+          message: `${mid} cannot run before ${dep} — ${mid} depends_on: [${dep}].`,
+        });
+      } else {
+        // Dep comes before — satisfied by position, redundant
+        redundant.push({ milestone: mid, dependsOn: dep });
+      }
+    }
+  }
+
+  // Check for circular dependencies
+  const visited = new Set<string>();
+  const inStack = new Set<string>();
+
+  function hasCycle(node: string, path: string[]): string[] | null {
+    if (inStack.has(node)) return [...path, node];
+    if (visited.has(node)) return null;
+
+    visited.add(node);
+    inStack.add(node);
+
+    const deps = depsMap.get(node) ?? [];
+    for (const dep of deps) {
+      if (completedIds.has(dep)) continue;
+      const cycle = hasCycle(dep, [...path, node]);
+      if (cycle) return cycle;
+    }
+
+    inStack.delete(node);
+    return null;
+  }
+
+  for (const mid of order) {
+    if (!visited.has(mid)) {
+      const cycle = hasCycle(mid, []);
+      if (cycle) {
+        const cycleStr = cycle.join(' → ');
+        violations.push({
+          milestone: cycle[0],
+          dependsOn: cycle[cycle.length - 2],
+          type: 'circular',
+          message: `Circular dependency: ${cycleStr}`,
+        });
+        break; // one cycle report is enough
+      }
+    }
+  }
+
+  return {
+    valid: violations.length === 0,
+    violations,
+    redundant,
+  };
+}

package/src/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/src/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/src/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/src/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/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");