gsd-pi 2.41.0 → 2.42.0-dev.eedc83f

package/src/resources/extensions/gsd/run-manager.ts

@@ -0,0 +1,180 @@
+/**
+ * run-manager.ts — Create and list isolated workflow run directories.
+ *
+ * Each run lives under `.gsd/workflow-runs/<name>/<timestamp>/` and contains:
+ * - DEFINITION.yaml — frozen snapshot of the workflow definition at run-creation time
+ * - GRAPH.yaml — initialized step graph with all steps pending
+ * - PARAMS.json — (optional) parameter overrides used for this run
+ *
+ * Observability:
+ * - All run state is on disk in human-readable YAML/JSON — inspectable with cat/less.
+ * - `listRuns()` returns structured metadata including step counts and overall status.
+ * - Timestamp directory names are filesystem-safe (ISO with hyphens replacing colons).
+ * - Errors include the full path context for diagnosis.
+ */
+
+import { mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { stringify } from "yaml";
+import { loadDefinition, substituteParams } from "./definition-loader.js";
+import { initializeGraph, writeGraph, readGraph } from "./graph.js";
+import type { WorkflowDefinition } from "./definition-loader.js";
+import type { WorkflowGraph } from "./graph.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────
+
+export interface RunMetadata {
+  /** Workflow definition name. */
+  name: string;
+  /** Filesystem-safe timestamp string used as dir name. */
+  timestamp: string;
+  /** Full path to the run directory. */
+  runDir: string;
+  /** Step counts derived from GRAPH.yaml. */
+  steps: { total: number; completed: number; pending: number; active: number };
+  /** Overall status derived from step states. */
+  status: "pending" | "running" | "complete";
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────
+
+const RUNS_DIR = "workflow-runs";
+const DEFS_DIR = "workflow-defs";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Generate a filesystem-safe timestamp: `YYYY-MM-DDTHH-MM-SS`.
+ * Replaces colons with hyphens so the string is safe as a directory name
+ * on all platforms (Windows forbids colons in paths).
+ */
+function makeTimestamp(date: Date = new Date()): string {
+  return date.toISOString().replace(/:/g, "-").replace(/\.\d{3}Z$/, "");
+}
+
+/**
+ * Derive overall status from a graph's step statuses.
+ */
+function deriveStatus(graph: WorkflowGraph): "pending" | "running" | "complete" {
+  const hasActive = graph.steps.some((s) => s.status === "active");
+  const allDone = graph.steps.every(
+    (s) => s.status === "complete" || s.status === "expanded",
+  );
+  if (allDone) return "complete";
+  if (hasActive) return "running";
+  return "pending";
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Create a new isolated run directory for a workflow definition.
+ *
+ * 1. Loads the definition from `<basePath>/.gsd/workflow-defs/<defName>.yaml`
+ * 2. Applies parameter substitution if overrides are provided
+ * 3. Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/`
+ * 4. Writes frozen DEFINITION.yaml, initialized GRAPH.yaml, and optional PARAMS.json
+ *
+ * @param basePath — project root directory
+ * @param defName — definition filename (without .yaml extension)
+ * @param overrides — optional parameter overrides (merged with definition defaults)
+ * @returns Full path to the created run directory
+ * @throws Error if the definition file doesn't exist or is invalid
+ */
+export function createRun(
+  basePath: string,
+  defName: string,
+  overrides?: Record<string, string>,
+): string {
+  const defsDir = join(basePath, ".gsd", DEFS_DIR);
+
+  // Load and validate the definition
+  const rawDef = loadDefinition(defsDir, defName);
+
+  // Apply parameter substitution if overrides provided
+  const def: WorkflowDefinition = overrides
+    ? substituteParams(rawDef, overrides)
+    : substituteParams(rawDef); // still resolve default params if any
+
+  // Create the run directory
+  const timestamp = makeTimestamp();
+  const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
+  mkdirSync(runDir, { recursive: true });
+
+  // Freeze the definition as DEFINITION.yaml
+  writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
+
+  // Initialize and write GRAPH.yaml
+  const graph = initializeGraph(def);
+  writeGraph(runDir, graph);
+
+  // Write PARAMS.json if overrides were provided
+  if (overrides && Object.keys(overrides).length > 0) {
+    writeFileSync(
+      join(runDir, "PARAMS.json"),
+      JSON.stringify(overrides, null, 2),
+      "utf-8",
+    );
+  }
+
+  return runDir;
+}
+
+/**
+ * List existing workflow runs with metadata.
+ *
+ * Scans `<basePath>/.gsd/workflow-runs/` for run directories. Each run's
+ * GRAPH.yaml is read to derive step counts and overall status.
+ *
+ * @param basePath — project root directory
+ * @param defName — optional filter: only list runs for this definition name
+ * @returns Array of run metadata, sorted newest-first within each definition
+ */
+export function listRuns(basePath: string, defName?: string): RunMetadata[] {
+  const runsRoot = join(basePath, ".gsd", RUNS_DIR);
+  if (!existsSync(runsRoot)) return [];
+
+  const results: RunMetadata[] = [];
+
+  // Get workflow name directories
+  const nameDirs = defName ? [defName] : readdirSync(runsRoot).filter((entry) => {
+    const full = join(runsRoot, entry);
+    return statSync(full).isDirectory();
+  });
+
+  for (const name of nameDirs) {
+    const nameDir = join(runsRoot, name);
+    if (!existsSync(nameDir)) continue;
+
+    const timestamps = readdirSync(nameDir).filter((entry) => {
+      const full = join(nameDir, entry);
+      return statSync(full).isDirectory();
+    });
+
+    // Sort newest-first (ISO strings sort lexicographically)
+    timestamps.sort().reverse();
+
+    for (const ts of timestamps) {
+      const runDir = join(nameDir, ts);
+      try {
+        const graph = readGraph(runDir);
+        const total = graph.steps.length;
+        const completed = graph.steps.filter((s) => s.status === "complete").length;
+        const pending = graph.steps.filter((s) => s.status === "pending").length;
+        const active = graph.steps.filter((s) => s.status === "active").length;
+
+        results.push({
+          name,
+          timestamp: ts,
+          runDir,
+          steps: { total, completed, pending, active },
+          status: deriveStatus(graph),
+        });
+      } catch {
+        // Skip runs with invalid/missing GRAPH.yaml
+      }
+    }
+  }
+
+  return results;
+}

package/src/resources/extensions/gsd/service-tier.ts

@@ -0,0 +1,184 @@
+/**
+ * Service Tier — gating, status formatting, icon resolution, and
+ * the /gsd fast command handler.
+ *
+ * Service tiers (priority/flex) are an OpenAI feature that only applies
+ * to gpt-5.4 variants. This module centralizes the model-gating logic
+ * so that icons, preferences, and the before_provider_request hook all
+ * use a single source of truth.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync } from "node:fs";
+import { saveFile } from "./files.js";
+import {
+  getGlobalGSDPreferencesPath,
+  loadEffectiveGSDPreferences,
+  loadGlobalGSDPreferences,
+} from "./preferences.js";
+import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type ServiceTierSetting = "priority" | "flex" | undefined;
+
+const SERVICE_TIER_SCOPE_NOTE = "Only affects gpt-5.4 models, regardless of provider.";
+
+// ─── Gating ──────────────────────────────────────────────────────────────────
+
+/**
+ * Returns true when the given model ID supports OpenAI service tiers.
+ * Currently only gpt-5.4 variants qualify.
+ */
+export function supportsServiceTier(modelId: string): boolean {
+  if (!modelId) return false;
+  // Strip provider prefix if present (e.g. "openai/gpt-5.4" → "gpt-5.4")
+  const bare = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  return bare.startsWith("gpt-5.4");
+}
+
+// ─── Status Formatting ───────────────────────────────────────────────────────
+
+/**
+ * Human-readable description of the current service tier setting.
+ */
+export function formatServiceTierStatus(tier: ServiceTierSetting): string {
+  if (!tier) {
+    return [
+      "Service tier: disabled",
+      "",
+      "Usage:",
+      "  /gsd fast on     Set to priority (2x cost, faster)",
+      "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+      "  /gsd fast off    Disable service tier",
+      "",
+      SERVICE_TIER_SCOPE_NOTE,
+    ].join("\n");
+  }
+
+  const label = tier === "priority" ? "priority (2x cost, faster)" : "flex (0.5x cost, slower)";
+  return [
+    `Service tier: ${label}`,
+    "",
+    "Usage:",
+    "  /gsd fast on     Set to priority (2x cost, faster)",
+    "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+    "  /gsd fast off    Disable service tier",
+    "",
+    SERVICE_TIER_SCOPE_NOTE,
+  ].join("\n");
+}
+
+export function formatServiceTierFooterStatus(
+  tier: ServiceTierSetting,
+  modelId: string | undefined,
+): string | undefined {
+  if (!tier || !modelId || !supportsServiceTier(modelId)) return undefined;
+  return tier === "priority" ? "fast: ⚡ priority" : "fast: 💰 flex";
+}
+
+// ─── Icon Resolution ─────────────────────────────────────────────────────────
+
+/**
+ * Returns the appropriate icon for the active service tier and model.
+ * Returns empty string when the tier is inactive or the model doesn't
+ * support service tiers.
+ */
+export function resolveServiceTierIcon(tier: ServiceTierSetting, modelId: string): string {
+  if (!tier || !supportsServiceTier(modelId)) return "";
+  return tier === "priority" ? "⚡" : "💰";
+}
+
+// ─── Preference Read ─────────────────────────────────────────────────────────
+
+/**
+ * Read the effective service_tier setting from preferences.
+ */
+export function getEffectiveServiceTier(): ServiceTierSetting {
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const raw = prefs?.service_tier;
+  if (raw === "priority" || raw === "flex") return raw;
+  return undefined;
+}
+
+// ─── Preference Write ────────────────────────────────────────────────────────
+
+function extractBodyAfterFrontmatter(content: string): string | null {
+  const start = content.startsWith("---\n") ? 4 : content.startsWith("---\r\n") ? 5 : -1;
+  if (start === -1) return null;
+  const closingIdx = content.indexOf("\n---", start);
+  if (closingIdx === -1) return null;
+  const after = content.slice(closingIdx + 4);
+  return after.trim() ? after : null;
+}
+
+async function writeGlobalServiceTier(
+  ctx: ExtensionCommandContext,
+  tier: ServiceTierSetting,
+): Promise<void> {
+  const path = getGlobalGSDPreferencesPath();
+  await ensurePreferencesFile(path, ctx, "global");
+
+  const existing = loadGlobalGSDPreferences();
+  const prefs: Record<string, unknown> = existing?.preferences ? { ...existing.preferences } : {};
+  prefs.version = prefs.version || 1;
+
+  if (tier) {
+    prefs.service_tier = tier;
+  } else {
+    delete prefs.service_tier;
+  }
+
+  const frontmatter = serializePreferencesToFrontmatter(prefs);
+  let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+  if (existsSync(path)) {
+    const preserved = extractBodyAfterFrontmatter(readFileSync(path, "utf-8"));
+    if (preserved) body = preserved;
+  }
+
+  await saveFile(path, `---\n${frontmatter}---${body}`);
+  await ctx.waitForIdle();
+  await ctx.reload();
+}
+
+// ─── Command Handler ─────────────────────────────────────────────────────────
+
+/**
+ * Handle `/gsd fast [on|off|flex|status]`.
+ */
+export async function handleFast(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const trimmed = args.trim().toLowerCase();
+
+  if (!trimmed || trimmed === "status") {
+    const tier = getEffectiveServiceTier();
+    ctx.ui.notify(formatServiceTierStatus(tier), "info");
+    return;
+  }
+
+  if (trimmed === "on") {
+    await writeGlobalServiceTier(ctx, "priority");
+    ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus("priority", ctx.model?.id));
+    ctx.ui.notify("Service tier set to priority (2x cost, faster responses). Only affects gpt-5.4 models, regardless of provider.", "info");
+    return;
+  }
+
+  if (trimmed === "off") {
+    await writeGlobalServiceTier(ctx, undefined);
+    ctx.ui.setStatus("gsd-fast", undefined);
+    ctx.ui.notify("Service tier disabled.", "info");
+    return;
+  }
+
+  if (trimmed === "flex") {
+    await writeGlobalServiceTier(ctx, "flex");
+    ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus("flex", ctx.model?.id));
+    ctx.ui.notify("Service tier set to flex (0.5x cost, slower responses). Only affects gpt-5.4 models, regardless of provider.", "info");
+    return;
+  }
+
+  ctx.ui.notify(
+    "Usage: /gsd fast [on|off|flex|status]\n\n  on    Priority tier (2x cost, faster)\n  off   Disable service tier\n  flex  Flex tier (0.5x cost, slower)\n  status Show current setting",
+    "warning",
+  );
+}

package/src/resources/extensions/gsd/session-lock.ts

@@ -239,7 +239,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
         const elapsed = Date.now() - _lockAcquiredAt;
         if (elapsed < 1_800_000) {
           process.stderr.write(
-            `[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — event loop stall, continuing.\n`,
+            `[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`,
           );
           return; // Suppress false positive
         }
@@ -299,7 +299,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
             const elapsed = Date.now() - _lockAcquiredAt;
             if (elapsed < 1_800_000) {
               process.stderr.write(
-                `[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — event loop stall, continuing.\n`,
+                `[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`,
               );
               return;
             }

package/src/resources/extensions/gsd/structured-data-formatter.ts

@@ -25,6 +25,7 @@ interface DecisionInput {
   choice: string;
   rationale: string;
   revisable: string;
+  made_by?: string;
 }
 
 interface RequirementInput {
@@ -61,6 +62,7 @@ export function formatDecisionCompact(decision: DecisionInput): string {
     decision.choice,
     decision.rationale,
     decision.revisable,
+    decision.made_by ?? 'agent',
   ].join(" | ");
 }
 
@@ -70,7 +72,7 @@ export function formatDecisionsCompact(decisions: DecisionInput[]): string {
     return "# Decisions (compact)\n(none)";
   }
 
-  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable";
+  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable | made_by";
   const lines = decisions.map(formatDecisionCompact);
   return `${header}\n\n${lines.join("\n")}`;
 }

package/src/resources/extensions/gsd/templates/decisions.md

@@ -4,5 +4,5 @@
      To reverse a decision, add a new row that supersedes it.
      Read this file at the start of any planning or research phase. -->
 
-| # | When | Scope | Decision | Choice | Rationale | Revisable? |
-|---|------|-------|----------|--------|-----------|------------|
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|

package/src/resources/extensions/gsd/tests/activity-log.test.ts

@@ -4,7 +4,7 @@
  *   - activity-log-save.test.ts (caching, dedup, collision recovery)
  */
 
-import test from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { existsSync, mkdtempSync, mkdirSync, readdirSync, realpathSync, rmSync, utimesSync, writeFileSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -48,9 +48,12 @@ function createCtx(entries: unknown[]) {
 
 // ── Pruning ──────────────────────────────────────────────────────────────────
 
-test("pruneActivityLogs deletes old files, keeps recent and highest-seq", () => {
-  const dir = createTmpDir();
-  try {
+describe("pruneActivityLogs", () => {
+  let dir: string;
+  beforeEach(() => { dir = createTmpDir(); });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  test("deletes old files, keeps recent and highest-seq", () => {
     const f001 = writeActivityFile(dir, "001", "execute-task-M001-S01-T01");
     writeActivityFile(dir, "002", "execute-task-M001-S01-T02");
     writeActivityFile(dir, "003", "execute-task-M001-S01-T03");
@@ -61,14 +64,9 @@ test("pruneActivityLogs deletes old files, keeps recent and highest-seq", () =>
     assert.ok(!remaining.includes("001-execute-task-M001-S01-T01.jsonl"));
     assert.ok(remaining.includes("002-execute-task-M001-S01-T02.jsonl"));
     assert.ok(remaining.includes("003-execute-task-M001-S01-T03.jsonl"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs preserves highest-seq even when all files are old", () => {
-  const dir = createTmpDir();
-  try {
+  test("preserves highest-seq even when all files are old", () => {
     const f001 = writeActivityFile(dir, "001", "t1");
     const f002 = writeActivityFile(dir, "002", "t2");
     const f003 = writeActivityFile(dir, "003", "t3");
@@ -78,14 +76,9 @@ test("pruneActivityLogs preserves highest-seq even when all files are old", () =
     const remaining = listFiles(dir);
     assert.equal(remaining.length, 1);
     assert.ok(remaining[0].startsWith("003-"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs with retentionDays=0 keeps only highest-seq", () => {
-  const dir = createTmpDir();
-  try {
+  test("with retentionDays=0 keeps only highest-seq", () => {
     writeActivityFile(dir, "001", "t1");
     writeActivityFile(dir, "002", "t2");
     writeActivityFile(dir, "003", "t3");
@@ -94,51 +87,31 @@ test("pruneActivityLogs with retentionDays=0 keeps only highest-seq", () => {
     const remaining = listFiles(dir);
     assert.equal(remaining.length, 1);
     assert.ok(remaining[0].startsWith("003-"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs no-op when all files are recent", () => {
-  const dir = createTmpDir();
-  try {
+  test("no-op when all files are recent", () => {
     writeActivityFile(dir, "001", "t1");
     writeActivityFile(dir, "002", "t2");
     writeActivityFile(dir, "003", "t3");
 
     pruneActivityLogs(dir, 30);
     assert.equal(listFiles(dir).length, 3);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs handles empty directory", () => {
-  const dir = createTmpDir();
-  try {
+  test("handles empty directory", () => {
     assert.doesNotThrow(() => pruneActivityLogs(dir, 30));
     assert.equal(readdirSync(dir).length, 0);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs preserves single old file (it is highest-seq)", () => {
-  const dir = createTmpDir();
-  try {
+  test("preserves single old file (it is highest-seq)", () => {
     const f = writeActivityFile(dir, "001", "t1");
     backdateFile(f, 100);
 
     pruneActivityLogs(dir, 30);
     assert.equal(listFiles(dir).length, 1);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("pruneActivityLogs ignores non-matching filenames", () => {
-  const dir = createTmpDir();
-  try {
+  test("ignores non-matching filenames", () => {
     const f001 = writeActivityFile(dir, "001", "t1");
     writeFileSync(join(dir, "notes.txt"), "some notes\n", "utf-8");
     backdateFile(f001, 40);
@@ -148,16 +121,17 @@ test("pruneActivityLogs ignores non-matching filenames", () => {
     assert.ok(remaining.includes("notes.txt"));
     // 001 is the only seq file, so it's highest-seq and survives
     assert.ok(remaining.includes("001-t1.jsonl"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+  });
 });
 
 // ── Save: caching, dedup, collision recovery ─────────────────────────────────
 
-test("saveActivityLog caches sequence instead of rescanning", () => {
-  const baseDir = createTmpDir();
-  try {
+describe("saveActivityLog", () => {
+  let baseDir: string;
+  beforeEach(() => { baseDir = createTmpDir(); });
+  afterEach(() => { rmSync(baseDir, { recursive: true, force: true }); });
+
+  test("caches sequence instead of rescanning", () => {
     saveActivityLog(createCtx([{ kind: "first", n: 1 }]) as any, baseDir, "execute-task", "M001/S01/T01");
     writeFileSync(join(activityDir(baseDir), "999-external.jsonl"), '{"x":1}\n', "utf-8");
     saveActivityLog(createCtx([{ kind: "second", n: 2 }]) as any, baseDir, "execute-task", "M001/S01/T02");
@@ -166,14 +140,9 @@ test("saveActivityLog caches sequence instead of rescanning", () => {
     assert.ok(files.includes("001-execute-task-M001-S01-T01.jsonl"));
     assert.ok(files.includes("002-execute-task-M001-S01-T02.jsonl"));
     assert.ok(!files.some(f => f.startsWith("1000-")));
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("saveActivityLog deduplicates identical snapshots for same unit", () => {
-  const baseDir = createTmpDir();
-  try {
+  test("deduplicates identical snapshots for same unit", () => {
     const ctx = createCtx([{ role: "assistant", content: "same" }]);
     saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
     saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
@@ -184,14 +153,9 @@ test("saveActivityLog deduplicates identical snapshots for same unit", () => {
     saveActivityLog(createCtx([{ role: "assistant", content: "changed" }]) as any, baseDir, "plan-slice", "M002/S01");
     files = listFiles(activityDir(baseDir));
     assert.equal(files.length, 2);
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("saveActivityLog recovers on sequence collision", () => {
-  const baseDir = createTmpDir();
-  try {
+  test("recovers on sequence collision", () => {
     saveActivityLog(createCtx([{ turn: 1 }]) as any, baseDir, "execute-task", "M003/S02/T01");
     writeFileSync(join(activityDir(baseDir), "002-execute-task-M003-S02-T02.jsonl"), '{"collision":true}\n', "utf-8");
     saveActivityLog(createCtx([{ turn: 2 }]) as any, baseDir, "execute-task", "M003/S02/T02");
@@ -199,9 +163,7 @@ test("saveActivityLog recovers on sequence collision", () => {
     const files = listFiles(activityDir(baseDir));
     assert.ok(files.includes("002-execute-task-M003-S02-T02.jsonl"));
     assert.ok(files.includes("003-execute-task-M003-S02-T02.jsonl"));
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
+  });
 });
 
 // ── Prompt text assertion ────────────────────────────────────────────────────