gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.3557dc4

package/src/resources/extensions/gsd/tests/rule-registry.test.ts

@@ -0,0 +1,413 @@
+// GSD Extension — Rule Registry Tests
+//
+// Tests the RuleRegistry class, UnifiedRule types, singleton accessors,
+// and evaluation methods using mock rules.
+
+import { test, describe, beforeEach } from "node:test";
+import { createTestContext } from "./test-helpers.ts";
+import {
+  RuleRegistry,
+  getRegistry,
+  setRegistry,
+  initRegistry,
+  resetRegistry,
+  convertDispatchRules,
+  getOrCreateRegistry,
+} from "../rule-registry.ts";
+import type { UnifiedRule } from "../rule-types.ts";
+import type { DispatchAction, DispatchContext } from "../auto-dispatch.ts";
+import { DISPATCH_RULES, getDispatchRuleNames } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+// ─── Mock Rule Factories ──────────────────────────────────────────────────
+
+function mockDispatchRule(name: string, matchPhase: string): UnifiedRule {
+  return {
+    name,
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async (ctx: DispatchContext): Promise<DispatchAction | null> => {
+      if (ctx.state.phase === matchPhase) {
+        return {
+          action: "dispatch",
+          unitType: `test-${matchPhase}`,
+          unitId: "test-id",
+          prompt: `Prompt for ${matchPhase}`,
+        };
+      }
+      return null;
+    },
+    then: () => {},
+    description: `Mock rule for ${matchPhase}`,
+  };
+}
+
+function makeContext(phase: string): DispatchContext {
+  return {
+    basePath: "/tmp/test",
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state: {
+      phase: phase as any,
+      activeMilestone: { id: "M001", title: "Test" },
+      activeSlice: null,
+      activeTask: null,
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "",
+      registry: [],
+    },
+    prefs: undefined,
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+describe("RuleRegistry", () => {
+  const { assertEq, assertTrue } = createTestContext();
+
+  beforeEach(() => {
+    resetRegistry();
+  });
+
+  test("construct with dispatch rules, listRules returns them", () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("rule-a", "planning"),
+      mockDispatchRule("rule-b", "executing"),
+      mockDispatchRule("rule-c", "complete"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const listed = registry.listRules();
+
+    // At minimum, dispatch rules are returned (hook rules depend on prefs)
+    const dispatchRules = listed.filter(r => r.when === "dispatch");
+    assertEq(dispatchRules.length, 3, "listRules returns 3 dispatch rules");
+    assertEq(dispatchRules[0].name, "rule-a", "first rule name is rule-a");
+    assertEq(dispatchRules[1].name, "rule-b", "second rule name is rule-b");
+    assertEq(dispatchRules[2].name, "rule-c", "third rule name is rule-c");
+  });
+
+  test("listRules returns correct fields on each rule", () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("check-fields", "planning"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const listed = registry.listRules();
+    const rule = listed.find(r => r.name === "check-fields")!;
+
+    assertTrue(rule !== undefined, "rule found by name");
+    assertEq(rule.when, "dispatch", "when field is dispatch");
+    assertEq(rule.evaluation, "first-match", "evaluation is first-match");
+    assertTrue(typeof rule.where === "function", "where is a function");
+    assertTrue(typeof rule.then === "function", "then is a function");
+    assertEq(rule.description, "Mock rule for planning", "description is set");
+  });
+
+  test("evaluateDispatch returns first matching rule", async () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("rule-planning", "planning"),
+      mockDispatchRule("rule-executing", "executing"),
+      mockDispatchRule("rule-complete", "complete"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const ctx = makeContext("executing");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "dispatch", "result is a dispatch action");
+    if (result.action === "dispatch") {
+      assertEq(result.unitType, "test-executing", "matched the executing rule");
+      assertEq(result.prompt, "Prompt for executing", "prompt from matched rule");
+    }
+  });
+
+  test("evaluateDispatch returns stop when no rule matches", async () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("only-planning", "planning"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const ctx = makeContext("blocked");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "stop", "result is a stop action");
+    if (result.action === "stop") {
+      assertTrue(result.reason.includes("blocked"), "stop reason mentions phase");
+    }
+  });
+
+  test("evaluateDispatch works with async where predicate", async () => {
+    const asyncRule: UnifiedRule = {
+      name: "async-rule",
+      when: "dispatch",
+      evaluation: "first-match",
+      where: async (ctx: DispatchContext): Promise<DispatchAction | null> => {
+        // Simulate async work
+        await new Promise(resolve => setTimeout(resolve, 1));
+        if (ctx.state.phase === "planning") {
+          return {
+            action: "dispatch",
+            unitType: "async-test",
+            unitId: "async-id",
+            prompt: "Async prompt",
+          };
+        }
+        return null;
+      },
+      then: () => {},
+    };
+
+    const registry = new RuleRegistry([asyncRule]);
+    const ctx = makeContext("planning");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "dispatch", "async dispatch resolved");
+    if (result.action === "dispatch") {
+      assertEq(result.unitType, "async-test", "async rule matched");
+    }
+  });
+
+  test("resetState clears all mutable state", () => {
+    const registry = new RuleRegistry([]);
+
+    // Set up some state
+    registry.activeHook = {
+      hookName: "test-hook",
+      triggerUnitType: "execute-task",
+      triggerUnitId: "M001/S01/T01",
+      cycle: 2,
+      pendingRetry: false,
+    };
+    registry.hookQueue.push({
+      config: { name: "q", after: [], prompt: "p" },
+      triggerUnitType: "execute-task",
+      triggerUnitId: "M001/S01/T02",
+    });
+    registry.cycleCounts.set("test/key", 3);
+    registry.retryPending = true;
+    registry.retryTrigger = { unitType: "execute-task", unitId: "M001/S01/T01", retryArtifact: "RETRY" };
+
+    // Reset
+    registry.resetState();
+
+    assertEq(registry.getActiveHook(), null, "activeHook cleared");
+    assertEq(registry.hookQueue.length, 0, "hookQueue cleared");
+    assertEq(registry.cycleCounts.size, 0, "cycleCounts cleared");
+    assertEq(registry.isRetryPending(), false, "retryPending cleared");
+    assertEq(registry.consumeRetryTrigger(), null, "retryTrigger cleared");
+  });
+
+  test("singleton getRegistry throws when not initialized", () => {
+    let threw = false;
+    try {
+      getRegistry();
+    } catch (e: any) {
+      threw = true;
+      assertTrue(e.message.includes("not initialized"), "error mentions not initialized");
+    }
+    assertTrue(threw, "getRegistry threw");
+  });
+
+  test("setRegistry / getRegistry round-trips", () => {
+    const registry = new RuleRegistry([mockDispatchRule("singleton-test", "planning")]);
+    setRegistry(registry);
+
+    const retrieved = getRegistry();
+    assertEq(retrieved, registry, "getRegistry returns the same instance");
+
+    const listed = retrieved.listRules().filter(r => r.when === "dispatch");
+    assertEq(listed.length, 1, "singleton has 1 dispatch rule");
+    assertEq(listed[0].name, "singleton-test", "rule name matches");
+  });
+
+  test("initRegistry creates and sets singleton", () => {
+    const rules = [mockDispatchRule("init-test", "executing")];
+    const registry = initRegistry(rules);
+
+    assertEq(getRegistry(), registry, "initRegistry sets the singleton");
+    const listed = getRegistry().listRules().filter(r => r.when === "dispatch");
+    assertEq(listed.length, 1, "singleton has the rule");
+  });
+
+  test("evaluateDispatch respects rule order (first match wins)", async () => {
+    // Both rules match "planning" but rule-first should win
+    const ruleFirst: UnifiedRule = {
+      name: "rule-first",
+      when: "dispatch",
+      evaluation: "first-match",
+      where: async (ctx: DispatchContext) => {
+        if (ctx.state.phase === "planning") {
+          return { action: "dispatch" as const, unitType: "first-wins", unitId: "id", prompt: "first" };
+        }
+        return null;
+      },
+      then: () => {},
+    };
+    const ruleSecond: UnifiedRule = {
+      name: "rule-second",
+      when: "dispatch",
+      evaluation: "first-match",
+      where: async (ctx: DispatchContext) => {
+        if (ctx.state.phase === "planning") {
+          return { action: "dispatch" as const, unitType: "second-loses", unitId: "id", prompt: "second" };
+        }
+        return null;
+      },
+      then: () => {},
+    };
+
+    const registry = new RuleRegistry([ruleFirst, ruleSecond]);
+    const ctx = makeContext("planning");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "dispatch", "dispatch action returned");
+    if (result.action === "dispatch") {
+      assertEq(result.unitType, "first-wins", "first rule won over second");
+    }
+  });
+
+  // ── Dispatch rule conversion tests ─────────────────────────────────
+
+  test("convertDispatchRules produces correct count of UnifiedRule objects", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    assertEq(converted.length, DISPATCH_RULES.length, `convertDispatchRules produces ${DISPATCH_RULES.length} rules`);
+  });
+
+  test("each converted rule has correct when, evaluation, and original name", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    for (let i = 0; i < converted.length; i++) {
+      const rule = converted[i];
+      assertEq(rule.when, "dispatch", `rule ${i} has when:"dispatch"`);
+      assertEq(rule.evaluation, "first-match", `rule ${i} has evaluation:"first-match"`);
+      assertEq(rule.name, DISPATCH_RULES[i].name, `rule ${i} preserves name "${DISPATCH_RULES[i].name}"`);
+      assertTrue(typeof rule.where === "function", `rule ${i} has a where function`);
+      assertTrue(typeof rule.then === "function", `rule ${i} has a then function`);
+    }
+  });
+
+  test("listRules after construction with real dispatch rules returns correct count", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    const registry = new RuleRegistry(converted);
+    const listed = registry.listRules().filter(r => r.when === "dispatch");
+    assertEq(listed.length, DISPATCH_RULES.length, `listRules returns ${DISPATCH_RULES.length} dispatch rules`);
+  });
+
+  test("rule names from listRules match getDispatchRuleNames in exact order", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    const registry = new RuleRegistry(converted);
+    const listedNames = registry.listRules()
+      .filter(r => r.when === "dispatch")
+      .map(r => r.name);
+    const originalNames = getDispatchRuleNames();
+
+    assertEq(listedNames.length, originalNames.length, "same number of names");
+    for (let i = 0; i < originalNames.length; i++) {
+      assertEq(listedNames[i], originalNames[i], `name at index ${i} matches: "${originalNames[i]}"`);
+    }
+  });
+
+  // ── getOrCreateRegistry (lazy init for facades) ────────────────────
+
+  test("getOrCreateRegistry lazily creates a registry with empty dispatch rules", () => {
+    // After resetRegistry(), getRegistry() would throw. getOrCreateRegistry() should not.
+    const registry = getOrCreateRegistry();
+    assertTrue(registry instanceof RuleRegistry, "returns a RuleRegistry instance");
+    const dispatchRules = registry.listRules().filter(r => r.when === "dispatch");
+    assertEq(dispatchRules.length, 0, "lazily-created registry has 0 dispatch rules");
+  });
+
+  test("getOrCreateRegistry returns existing registry when initialized", () => {
+    const rules = [mockDispatchRule("explicit-init", "planning")];
+    const explicit = initRegistry(rules);
+    const lazy = getOrCreateRegistry();
+    assertEq(lazy, explicit, "getOrCreateRegistry returns the same singleton as initRegistry");
+    const dispatchRules = lazy.listRules().filter(r => r.when === "dispatch");
+    assertEq(dispatchRules.length, 1, "singleton has the explicitly initialized dispatch rule");
+  });
+
+  // ── Hook-derived rules in listRules ────────────────────────────────
+
+  test("listRules returns only dispatch rules when no hooks are configured", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    const registry = new RuleRegistry(converted);
+    const allRules = registry.listRules();
+    const postUnitRules = allRules.filter(r => r.when === "post-unit");
+    const preDispatchRules = allRules.filter(r => r.when === "pre-dispatch");
+
+    // No preferences file = no hooks
+    assertEq(postUnitRules.length, 0, "no post-unit rules when no hooks configured");
+    assertEq(preDispatchRules.length, 0, "no pre-dispatch rules when no hooks configured");
+    assertEq(allRules.length, DISPATCH_RULES.length, "total rules equals dispatch rules only");
+  });
+
+  test("listRules dispatch rules appear first, hooks after", () => {
+    const converted = convertDispatchRules(DISPATCH_RULES);
+    const registry = new RuleRegistry(converted);
+    const allRules = registry.listRules();
+
+    // Verify dispatch rules come first (indices 0..N-1)
+    for (let i = 0; i < converted.length; i++) {
+      assertEq(allRules[i].when, "dispatch", `rule at index ${i} is a dispatch rule`);
+      assertEq(allRules[i].name, converted[i].name, `dispatch rule at index ${i} has correct name`);
+    }
+  });
+
+  // ── Facade delegation (post-unit-hooks.ts imports work through registry) ──
+
+  test("evaluatePostUnit returns null for hook-on-hook prevention", () => {
+    const registry = new RuleRegistry([]);
+    const result = registry.evaluatePostUnit("hook/code-review", "M001/S01/T01", "/tmp/test");
+    assertEq(result, null, "hook units don't trigger other hooks");
+  });
+
+  test("evaluatePostUnit returns null for triage-captures", () => {
+    const registry = new RuleRegistry([]);
+    const result = registry.evaluatePostUnit("triage-captures", "M001/S01/T01", "/tmp/test");
+    assertEq(result, null, "triage-captures skipped");
+  });
+
+  test("evaluatePostUnit returns null for quick-task", () => {
+    const registry = new RuleRegistry([]);
+    const result = registry.evaluatePostUnit("quick-task", "M001/S01/T01", "/tmp/test");
+    assertEq(result, null, "quick-task skipped");
+  });
+
+  test("evaluatePreDispatch bypasses hook units", () => {
+    const registry = new RuleRegistry([]);
+    const result = registry.evaluatePreDispatch("hook/review", "M001/S01/T01", "prompt", "/tmp/test");
+    assertEq(result.action, "proceed", "hook units always proceed");
+    assertEq(result.prompt, "prompt", "prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired");
+  });
+
+  test("evaluatePreDispatch proceeds with empty hooks", () => {
+    const registry = new RuleRegistry([]);
+    const result = registry.evaluatePreDispatch("execute-task", "M001/S01/T01", "original prompt", "/tmp/test");
+    assertEq(result.action, "proceed", "proceeds when no hooks");
+    assertEq(result.prompt, "original prompt", "prompt unchanged");
+  });
+
+  // ── matchedRule provenance (S02 journal support) ───────────────────
+
+  test("evaluateDispatch result includes matchedRule on dispatch match", async () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("my-planning-rule", "planning"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const ctx = makeContext("planning");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "dispatch", "result is a dispatch action");
+    assertEq(result.matchedRule, "my-planning-rule", "matchedRule is the rule name");
+  });
+
+  test("evaluateDispatch result includes matchedRule '<no-match>' on fallback stop", async () => {
+    const rules: UnifiedRule[] = [
+      mockDispatchRule("only-planning", "planning"),
+    ];
+    const registry = new RuleRegistry(rules);
+    const ctx = makeContext("some-unknown-phase");
+    const result = await registry.evaluateDispatch(ctx);
+
+    assertEq(result.action, "stop", "result is a stop action");
+    assertEq(result.matchedRule, "<no-match>", "matchedRule is '<no-match>' on fallback");
+  });
+});

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

@@ -0,0 +1,98 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  supportsServiceTier,
+  formatServiceTierStatus,
+  resolveServiceTierIcon,
+  type ServiceTierSetting,
+} from "../service-tier.ts";
+
+// ─── supportsServiceTier ─────────────────────────────────────────────────────
+
+describe("supportsServiceTier", () => {
+  test("returns true for gpt-5.4", () => {
+    assert.equal(supportsServiceTier("gpt-5.4"), true);
+  });
+
+  test("returns true for gpt-5.4-pro", () => {
+    assert.equal(supportsServiceTier("gpt-5.4-pro"), true);
+  });
+
+  test("returns true for gpt-5.4-mini", () => {
+    assert.equal(supportsServiceTier("gpt-5.4-mini"), true);
+  });
+
+  test("returns true for openai/gpt-5.4 (provider-prefixed)", () => {
+    assert.equal(supportsServiceTier("openai/gpt-5.4"), true);
+  });
+
+  test("returns false for claude-opus-4-6", () => {
+    assert.equal(supportsServiceTier("claude-opus-4-6"), false);
+  });
+
+  test("returns false for gemini-2.5-pro", () => {
+    assert.equal(supportsServiceTier("gemini-2.5-pro"), false);
+  });
+
+  test("returns false for gpt-4o", () => {
+    assert.equal(supportsServiceTier("gpt-4o"), false);
+  });
+
+  test("returns false for empty string", () => {
+    assert.equal(supportsServiceTier(""), false);
+  });
+});
+
+// ─── formatServiceTierStatus ─────────────────────────────────────────────────
+
+describe("formatServiceTierStatus", () => {
+  test("shows disabled when service_tier is undefined", () => {
+    const output = formatServiceTierStatus(undefined);
+    assert.ok(output.includes("disabled"), `Expected 'disabled' in: ${output}`);
+  });
+
+  test("shows priority when set to priority", () => {
+    const output = formatServiceTierStatus("priority");
+    assert.ok(output.includes("priority"), `Expected 'priority' in: ${output}`);
+  });
+
+  test("shows flex when set to flex", () => {
+    const output = formatServiceTierStatus("flex");
+    assert.ok(output.includes("flex"), `Expected 'flex' in: ${output}`);
+  });
+});
+
+// ─── resolveServiceTierIcon ──────────────────────────────────────────────────
+
+describe("resolveServiceTierIcon", () => {
+  test("returns lightning bolt for priority tier on supported model", () => {
+    const icon = resolveServiceTierIcon("priority", "gpt-5.4");
+    assert.equal(icon, "⚡");
+  });
+
+  test("returns money icon for flex tier on supported model", () => {
+    const icon = resolveServiceTierIcon("flex", "gpt-5.4");
+    assert.equal(icon, "💰");
+  });
+
+  test("returns empty string when tier is set but model does not support it", () => {
+    const icon = resolveServiceTierIcon("priority", "claude-opus-4-6");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when tier is undefined", () => {
+    const icon = resolveServiceTierIcon(undefined, "gpt-5.4");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when both tier and model are unsupported", () => {
+    const icon = resolveServiceTierIcon(undefined, "claude-opus-4-6");
+    assert.equal(icon, "");
+  });
+
+  test("returns empty string when model is empty", () => {
+    const icon = resolveServiceTierIcon("priority", "");
+    assert.equal(icon, "");
+  });
+});

package/src/resources/extensions/gsd/tests/skill-lifecycle.test.ts

@@ -3,7 +3,7 @@
  * Tests the pure functions — no file I/O, no extension context.
  */
 
-import { describe, it, beforeEach } from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import type { UnitMetrics } from "../metrics.js";
 
@@ -72,7 +72,7 @@ describe("skill-health", () => {
 
     // With no metrics file, should return empty
     const result = computeStaleAvoidList("/nonexistent/path", ["some-skill"]);
-    assert.ok(Array.isArray(result));
+    assert.deepEqual(result, []);
   });
 });
 

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Regression test for #1855: Stalled tool detection crashes with
+ * "The path argument must be of type string. Received undefined"
+ *
+ * When a tool stalls in-flight for 10+ minutes, the idle watchdog fires
+ * recoverTimedOutUnit(). In auto/phases.ts, buildRecoveryContext was
+ * returning an empty object `{}`, so basePath was undefined. The recovery
+ * code passed undefined to readUnitRuntimeRecord → runtimePath → join(),
+ * which throws a TypeError. The session is permanently frozen because the
+ * error propagates into the idle watchdog catch handler but the unit
+ * promise is never resolved.
+ *
+ * This test calls recoverTimedOutUnit with an empty RecoveryContext (the
+ * bug) and verifies it crashes, then calls it with a valid RecoveryContext
+ * (the fix) and verifies it does not crash.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertTrue, report } = createTestContext();
+
+// Minimal mock for ExtensionContext — only the fields recoverTimedOutUnit touches.
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: () => {},
+    },
+  } as any;
+}
+
+// Minimal mock for ExtensionAPI — only sendMessage is called during recovery.
+function makeMockPi() {
+  return {
+    sendMessage: () => {},
+  } as any;
+}
+
+// ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
+
+{
+  console.log("\n=== #1855: recoverTimedOutUnit crashes when basePath is undefined ===");
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+
+  // Simulate the bug: buildRecoveryContext returns {} (empty object).
+  // basePath is undefined, which causes join(undefined, ".gsd") to throw.
+  const emptyRctx = {} as RecoveryContext;
+
+  let crashed = false;
+  try {
+    await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", emptyRctx);
+  } catch (err: any) {
+    crashed = true;
+    assertTrue(
+      err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
+      `should crash with path/type error, got: ${err.message}`,
+    );
+  }
+  assertTrue(crashed, "should crash when basePath is undefined (reproduces #1855)");
+}
+
+// ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
+
+{
+  console.log("\n=== #1855: recoverTimedOutUnit succeeds with valid RecoveryContext ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-stalled-tool-test-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "runtime", "units"), { recursive: true });
+
+  try {
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+
+    const validRctx: RecoveryContext = {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    };
+
+    let crashed = false;
+    let result: string | undefined;
+    try {
+      result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", validRctx);
+    } catch (err: any) {
+      crashed = true;
+      console.error(`  Unexpected crash: ${err.message}`);
+    }
+    assertTrue(!crashed, "should not crash with valid basePath");
+    // With no runtime record on disk and recoveryAttempts=0, the function
+    // should attempt steering recovery (sendMessage) and return "recovered".
+    assertTrue(result === "recovered", `should return 'recovered', got '${result}'`);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+report();

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

@@ -86,16 +86,17 @@ describe("structured-data-formatter: formatDecisionCompact", () => {
     const result = formatDecisionCompact(sampleDecision);
     assert.equal(
       result,
-      "D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode, single-writer | Built-in, no external deps | yes",
+      "D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode, single-writer | Built-in, no external deps | yes | agent",
     );
   });
 
   it("includes all fields in the correct order", () => {
     const result = formatDecisionCompact(sampleDecision);
     const parts = result.split(" | ");
-    assert.equal(parts.length, 7);
+    assert.equal(parts.length, 8);
     assert.equal(parts[0], "D001");
     assert.equal(parts[6], "yes");
+    assert.equal(parts[7], "agent");
   });
 });
 
@@ -107,7 +108,7 @@ describe("structured-data-formatter: formatDecisionsCompact", () => {
   it("includes Fields header line", () => {
     const result = formatDecisionsCompact([sampleDecision]);
     assert.ok(result.startsWith("# Decisions (compact)"));
-    assert.ok(result.includes("Fields: id | when | scope | decision | choice | rationale | revisable"));
+    assert.ok(result.includes("Fields: id | when | scope | decision | choice | rationale | revisable | made_by"));
   });
 
   it("formats multiple decisions on separate lines", () => {