refactor: deduplicate E2E tests to reduce LLM API calls

.github/workflows/e2e.yml

@@ -30,12 +30,10 @@ jobs:
               e2e/perstack-cli/run.test.ts
               e2e/perstack-cli/options.test.ts
               e2e/perstack-cli/skills.test.ts
-              e2e/perstack-cli/limits.test.ts
               e2e/perstack-cli/lockfile.test.ts
               e2e/perstack-cli/providers.test.ts
               e2e/perstack-cli/error-handling.test.ts
               e2e/perstack-cli/interactive.test.ts
-              e2e/perstack-cli/runtime-interactive.test.ts
               e2e/perstack-cli/lazy-init.test.ts
               e2e/perstack-cli/bundled-base.test.ts
               e2e/perstack-cli/versioned-base.test.ts

e2e/perstack-cli/continue.test.ts

@@ -136,33 +136,20 @@ describe.concurrent("Continue Job", () => {
 
   /**
    * Verifies checkpoint ID is captured for resume-from functionality.
+   * Also verifies run stops at interactive tool with correct event sequence.
    */
   it("should capture checkpoint ID for resume-from", async () => {
     const cmdResult = await runCli(runArgs("e2e-continue", "Test continue/resume functionality"), {
       timeout: LLM_TIMEOUT,
     })
     const result = withEventParsing(cmdResult)
+    expect(
+      assertEventSequenceContains(result.events, ["startRun", "stopRunByInteractiveTool"]).passed,
+    ).toBe(true)
     const stopEvents = filterEventsByType(result.events, "stopRunByInteractiveTool")
     expect(stopEvents.length).toBe(1)
     const checkpoint = (stopEvents[0] as { checkpoint?: { id?: string } }).checkpoint
     expect(checkpoint?.id).toBeDefined()
     expect(typeof checkpoint?.id).toBe("string")
   })
-
-  /**
-   * Verifies --resume-from requires --continue-job option.
-   */
-  it("should fail when --resume-from is used without --continue-job", async () => {
-    const result = await runCli([
-      "run",
-      "--config",
-      CONTINUE_CONFIG,
-      "--resume-from",
-      "checkpoint-123",
-      "e2e-continue",
-      "test",
-    ])
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain("--resume-from requires --continue-job")
-  })
 })

e2e/perstack-cli/options.test.ts

@@ -59,11 +59,11 @@ describe.concurrent("CLI Options", () => {
     LLM_TIMEOUT,
   )
 
-  /** Verifies --max-steps option is accepted. */
+  /** Verifies --max-steps option is accepted and run completes. */
   it(
     "should accept --max-steps option",
     async () => {
-      const result = await runCli(
+      const cmdResult = await runCli(
         [
           "run",
           "--config",
@@ -75,7 +75,11 @@ describe.concurrent("CLI Options", () => {
         ],
         { timeout: LLM_TIMEOUT },
       )
+      const result = withEventParsing(cmdResult)
       expect(result.exitCode).toBe(0)
+      expect(assertEventSequenceContains(result.events, ["startRun", "completeRun"]).passed).toBe(
+        true,
+      )
     },
     LLM_TIMEOUT,
   )

e2e/perstack-cli/published-expert.test.ts

@@ -4,18 +4,13 @@
  * Tests error handling for published expert resolution:
  * - Nonexistent published experts (e.g., @user/expert)
  * - Invalid expert key formats
- * - Failed delegation to nonexistent published experts
  *
  * These tests verify graceful error handling without LLM API calls
  * (errors occur before LLM generation starts).
- *
- * TOML: e2e/experts/error-handling.toml
  */
 import { describe, expect, it } from "vitest"
 import { runCli } from "../lib/runner.js"
 
-const CONFIG = "./e2e/experts/error-handling.toml"
-
 describe.concurrent("Published Expert", () => {
   /** Verifies error message for nonexistent @user/expert format */
   it("should fail gracefully for nonexistent published expert", async () => {
@@ -29,10 +24,4 @@ describe.concurrent("Published Expert", () => {
     const result = await runCli(["run", "@invalid", "test query"])
     expect(result.exitCode).toBe(1)
   })
-
-  /** Verifies error when expert tries to delegate to nonexistent expert */
-  it("should fail gracefully when delegating to nonexistent published expert", async () => {
-    const result = await runCli(["run", "--config", CONFIG, "e2e-invalid-delegate", "test"])
-    expect(result.exitCode).not.toBe(0)
-  })
 })

e2e/perstack-cli/reasoning-budget.test.ts

@@ -115,43 +115,6 @@ describe("Reasoning Budget", () => {
       LLM_TIMEOUT,
     )
 
-    it(
-      "should emit streaming reasoning events",
-      async () => {
-        const expertKey = "e2e-reasoning-anthropic-medium"
-        const cmdResult = await runCli(
-          [
-            "run",
-            "--config",
-            REASONING_BUDGET_CONFIG,
-            expertKey,
-            "Calculate 3+3",
-            "--provider",
-            "anthropic",
-            "--model",
-            ANTHROPIC_MODEL,
-            "--reasoning-budget",
-            "medium",
-          ],
-          { timeout: LLM_TIMEOUT },
-        )
-        const result = withEventParsing(cmdResult)
-
-        expect(result.exitCode).toBe(0)
-
-        // Verify streaming events were emitted (renamed in state-machine-redesign)
-        const streamReasoningEvents = result.events.filter((e) => e.type === "streamReasoning")
-        expect(streamReasoningEvents.length).toBeGreaterThan(0)
-
-        // Verify completeStreamingReasoning is emitted at least once
-        const completeReasoningEvents = result.events.filter(
-          (e) => e.type === "completeStreamingReasoning",
-        )
-        expect(completeReasoningEvents.length).toBeGreaterThan(0)
-      },
-      LLM_TIMEOUT,
-    )
-
     it(
       "should produce more reasoning tokens with higher budget",
       async () => {