@vellumai/cli 0.7.0 → 0.7.1

package/src/components/DefaultMainScreen.tsx

@@ -19,6 +19,7 @@ import { SPECIES_CONFIG, type Species } from "../lib/constants";
 import { callDoctorDaemon, type ChatLogEntry } from "../lib/doctor-client";
 import { checkHealth } from "../lib/health-check";
 import { appendHistory, loadHistory } from "../lib/input-history";
+import { tuiLog } from "../lib/tui-log";
 import { statusEmoji, withStatusEmoji } from "../lib/status-emoji";
 import {
   getTerminalCapabilities,
@@ -354,22 +355,35 @@ async function* streamEvents(
 ): AsyncGenerator<SseEvent> {
   const params = new URLSearchParams({ conversationKey });
   const url = `${baseUrl}/v1/assistants/${assistantId}/events?${params.toString()}`;
+  const clientHeaders = getClientRegistrationHeaders();
+  tuiLog.info("sse connect", { url, clientHeaders });
   const response = await fetch(url, {
     headers: {
       Accept: "text/event-stream",
       ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {}),
-      ...getClientRegistrationHeaders(),
+      ...clientHeaders,
     },
     signal,
   });
 
+  tuiLog.info("sse response", {
+    status: response.status,
+    statusText: response.statusText,
+    contentType: response.headers.get("content-type"),
+  });
+
   if (!response.ok) {
     const body = await response.text().catch(() => "");
+    tuiLog.error("sse connection failed", {
+      status: response.status,
+      body: body.slice(0, 500),
+    });
     throw new Error(
       `SSE connection failed (${response.status}): ${body || response.statusText}`,
     );
   }
   if (!response.body) {
+    tuiLog.error("sse response has no body");
     throw new Error("No response body from SSE endpoint");
   }
 
@@ -1653,6 +1667,10 @@ function ChatApp({
 
     try {
       const health = await checkHealthRuntime(runtimeUrl);
+      tuiLog.info("health check", {
+        status: health.status,
+        message: health.message,
+      });
       h.hideSpinner();
       h.updateHealthStatus(health.status);
       if (health.status === "healthy" || health.status === "ok") {
@@ -1850,9 +1868,12 @@ function ChatApp({
                 break;
             }
           }
-        } catch {
+        } catch (sseErr) {
           // Stream ended — only report if not intentionally aborted
           if (!sseAc.signal.aborted) {
+            tuiLog.warn("sse stream disconnected", {
+              error: String(sseErr),
+            });
             handleRef_.current?.addStatus(
               "SSE stream disconnected — will reconnect on next message",
               "yellow",
@@ -1869,10 +1890,11 @@ function ChatApp({
       setConnectionState("connected");
       return true;
     } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      tuiLog.error("connection failed", { error: msg });
       h.hideSpinner();
       connectingRef.current = false;
       h.updateHealthStatus("unreachable");
-      const msg = err instanceof Error ? err.message : String(err);
       setConnectionState("error");
       setConnectionError(msg);
       h.addStatus(

package/src/index.ts

@@ -27,9 +27,7 @@ import { upgrade } from "./commands/upgrade";
 import { use } from "./commands/use";
 import { wake } from "./commands/wake";
 import {
-  getActiveAssistant,
-  findAssistantByName,
-  loadLatestAssistant,
+  resolveAssistant,
   setActiveAssistant,
 } from "./lib/assistant-config";
 import { loadGuardianToken } from "./lib/guardian-token";
@@ -129,10 +127,7 @@ function applyNoColorFlags(argv: string[]): void {
  * Otherwise return false so the caller can fall back to help text.
  */
 async function tryLaunchClient(): Promise<boolean> {
-  const activeName = getActiveAssistant();
-  const entry = activeName
-    ? findAssistantByName(activeName)
-    : loadLatestAssistant();
+  const entry = resolveAssistant();
 
   if (!entry) return false;
 

package/src/lib/__tests__/local-runtime-client.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { AssistantEntry } from "../assistant-config.js";
 import {
   MigrationInProgressError,
   localRuntimeExportToGcs,
@@ -10,6 +11,17 @@ import {
 const RUNTIME_URL = "http://127.0.0.1:8765";
 const TOKEN = "local-bearer-token";
 
+// All tests in this file exercise the local/docker code path (cloud="local"),
+// which builds `{runtimeUrl}/v1/migrations/<subpath>` URLs and uses
+// guardian-token bearer auth. The platform path (cloud="vellum") is covered
+// by `runtime-url.test.ts` (URL construction) and the teleport tests
+// (call-site wiring).
+const ENTRY: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId"> = {
+  cloud: "local",
+  runtimeUrl: RUNTIME_URL,
+  assistantId: "ast-test-1",
+};
+
 interface CapturedCall {
   url: string;
   method: string;
@@ -82,7 +94,7 @@ describe("localRuntimeExportToGcs", () => {
     });
     globalThis.fetch = fetchMock;
 
-    const result = await localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+    const result = await localRuntimeExportToGcs(ENTRY, TOKEN, {
       uploadUrl: "https://storage.example/signed/abc",
       description: "teleport export",
     });
@@ -108,7 +120,7 @@ describe("localRuntimeExportToGcs", () => {
     });
     globalThis.fetch = fetchMock;
 
-    await localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+    await localRuntimeExportToGcs(ENTRY, TOKEN, {
       uploadUrl: "https://storage.example/signed/abc",
     });
 
@@ -132,7 +144,7 @@ describe("localRuntimeExportToGcs", () => {
     globalThis.fetch = fetchMock;
 
     try {
-      await localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+      await localRuntimeExportToGcs(ENTRY, TOKEN, {
         uploadUrl: "https://storage.example/signed/abc",
       });
       throw new Error("expected to throw");
@@ -156,7 +168,7 @@ describe("localRuntimeExportToGcs", () => {
     globalThis.fetch = fetchMock;
 
     try {
-      await localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+      await localRuntimeExportToGcs(ENTRY, TOKEN, {
         uploadUrl: "https://storage.example/signed/abc",
       });
       throw new Error("expected to throw");
@@ -182,7 +194,7 @@ describe("localRuntimeExportToGcs", () => {
     globalThis.fetch = fetchMock;
 
     try {
-      await localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+      await localRuntimeExportToGcs(ENTRY, TOKEN, {
         uploadUrl: "https://storage.example/signed/abc",
       });
       throw new Error("expected to throw");
@@ -201,7 +213,7 @@ describe("localRuntimeExportToGcs", () => {
     globalThis.fetch = fetchMock;
 
     await expect(
-      localRuntimeExportToGcs(RUNTIME_URL, TOKEN, {
+      localRuntimeExportToGcs(ENTRY, TOKEN, {
         uploadUrl: "https://storage.example/signed/abc",
       }),
     ).rejects.toThrow(/500/);
@@ -222,7 +234,7 @@ describe("localRuntimeImportFromGcs", () => {
     });
     globalThis.fetch = fetchMock;
 
-    const result = await localRuntimeImportFromGcs(RUNTIME_URL, TOKEN, {
+    const result = await localRuntimeImportFromGcs(ENTRY, TOKEN, {
       bundleUrl: "https://storage.example/signed/dl-xyz",
     });
 
@@ -250,7 +262,7 @@ describe("localRuntimeImportFromGcs", () => {
     globalThis.fetch = fetchMock;
 
     try {
-      await localRuntimeImportFromGcs(RUNTIME_URL, TOKEN, {
+      await localRuntimeImportFromGcs(ENTRY, TOKEN, {
         bundleUrl: "https://storage.example/signed/dl-xyz",
       });
       throw new Error("expected to throw");
@@ -275,7 +287,7 @@ describe("localRuntimeImportFromGcs", () => {
     globalThis.fetch = fetchMock;
 
     try {
-      await localRuntimeImportFromGcs(RUNTIME_URL, TOKEN, {
+      await localRuntimeImportFromGcs(ENTRY, TOKEN, {
         bundleUrl: "https://storage.example/signed/dl-xyz",
       });
       throw new Error("expected to throw");
@@ -302,11 +314,7 @@ describe("localRuntimePollJobStatus", () => {
     });
     globalThis.fetch = fetchMock;
 
-    const status = await localRuntimePollJobStatus(
-      RUNTIME_URL,
-      TOKEN,
-      "poll-1",
-    );
+    const status = await localRuntimePollJobStatus(ENTRY, TOKEN, "poll-1");
 
     expect(status).toEqual({
       jobId: "poll-1",
@@ -332,11 +340,7 @@ describe("localRuntimePollJobStatus", () => {
     });
     globalThis.fetch = fetchMock;
 
-    const status = await localRuntimePollJobStatus(
-      RUNTIME_URL,
-      TOKEN,
-      "poll-2",
-    );
+    const status = await localRuntimePollJobStatus(ENTRY, TOKEN, "poll-2");
 
     expect(status.status).toBe("complete");
     if (status.status === "complete") {
@@ -358,11 +362,7 @@ describe("localRuntimePollJobStatus", () => {
     });
     globalThis.fetch = fetchMock;
 
-    const status = await localRuntimePollJobStatus(
-      RUNTIME_URL,
-      TOKEN,
-      "poll-3",
-    );
+    const status = await localRuntimePollJobStatus(ENTRY, TOKEN, "poll-3");
 
     expect(status.status).toBe("failed");
     if (status.status === "failed") {
@@ -377,7 +377,104 @@ describe("localRuntimePollJobStatus", () => {
     globalThis.fetch = fetchMock;
 
     await expect(
-      localRuntimePollJobStatus(RUNTIME_URL, TOKEN, "missing"),
+      localRuntimePollJobStatus(ENTRY, TOKEN, "missing"),
     ).rejects.toThrow(/Migration job not found/);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Platform-managed assistants (cloud="vellum") route through the platform's
+// wildcard runtime proxy at `/v1/assistants/<id>/migrations/...` with
+// platform-token auth (NOT guardian-token bearer). This block asserts the
+// actual URL and headers built by the helpers — not mocked, not abstracted.
+// Regression guard for the routing bug fixed in this PR.
+// ---------------------------------------------------------------------------
+const VELLUM_ENTRY: Pick<
+  AssistantEntry,
+  "cloud" | "runtimeUrl" | "assistantId"
+> = {
+  cloud: "vellum",
+  runtimeUrl: "https://platform.vellum.ai",
+  assistantId: "11111111-2222-3333-4444-555555555555",
+};
+// `vak_` prefix bypasses `fetchOrganizationId` (org-scoped API keys); the
+// auth header collapses to a single `Authorization: Bearer vak_...` so this
+// test stays free of network mocks.
+const VAK_TOKEN = "vak_platform-token";
+
+describe("vellum-cloud routing through wildcard proxy", () => {
+  test("export-to-gcs URL has /v1/assistants/<id>/migrations/ prefix and uses platform-token bearer (no guardian)", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({ job_id: "wp-export-1", status: "pending" }),
+        { status: 202, headers: { "Content-Type": "application/json" } },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const result = await localRuntimeExportToGcs(VELLUM_ENTRY, VAK_TOKEN, {
+      uploadUrl: "https://storage.example/signed/x",
+      description: "teleport export",
+    });
+
+    expect(result.jobId).toBe("wp-export-1");
+    expect(calls[0]!.url).toBe(
+      `https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/export-to-gcs`,
+    );
+    expect(calls[0]!.method).toBe("POST");
+    expect(calls[0]!.headers.Authorization).toBe(`Bearer ${VAK_TOKEN}`);
+    expect(calls[0]!.body).toEqual({
+      upload_url: "https://storage.example/signed/x",
+      description: "teleport export",
+    });
+  });
+
+  test("import-from-gcs URL has /v1/assistants/<id>/migrations/ prefix", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({ job_id: "wp-import-1", status: "pending" }),
+        { status: 202 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    await localRuntimeImportFromGcs(VELLUM_ENTRY, VAK_TOKEN, {
+      bundleUrl: "https://storage.example/download/y",
+    });
+
+    expect(calls[0]!.url).toBe(
+      `https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/import-from-gcs`,
+    );
+    expect(calls[0]!.headers.Authorization).toBe(`Bearer ${VAK_TOKEN}`);
+  });
+
+  test("jobs/<id> URL has /v1/assistants/<id>/migrations/ prefix (NOT the dedicated platform endpoint)", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          job_id: "wp-export-1",
+          status: "complete",
+          type: "export",
+          bundle_key: "exports/org-1/x.vbundle",
+        }),
+        { status: 200 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const status = await localRuntimePollJobStatus(
+      VELLUM_ENTRY,
+      VAK_TOKEN,
+      "wp-export-1",
+    );
+
+    expect(calls[0]!.url).toBe(
+      `https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/jobs/wp-export-1`,
+    );
+    expect(calls[0]!.headers.Authorization).toBe(`Bearer ${VAK_TOKEN}`);
+    expect(status.status).toBe("complete");
+    if (status.status === "complete") {
+      expect(status.bundleKey).toBe("exports/org-1/x.vbundle");
+    }
+  });
+});

package/src/lib/__tests__/platform-client-signed-url.test.ts

@@ -291,7 +291,7 @@ describe("platformRequestSignedUrl", () => {
     expect(signedUrlCalls[0]!.headers.Authorization).toBeUndefined();
   });
 
-  test("503 → throws so callers can fall back to legacy inline upload", async () => {
+  test("5xx error response → surfaces platform detail message", async () => {
     const { fetchMock } = captureFetch(() => {
       return new Response(JSON.stringify({ detail: "temporarily down" }), {
         status: 503,
@@ -305,7 +305,7 @@ describe("platformRequestSignedUrl", () => {
         VAK_TOKEN,
         PLATFORM_URL,
       ),
-    ).rejects.toThrow(/503/);
+    ).rejects.toThrow(/temporarily down/);
   });
 });
 

package/src/lib/__tests__/runtime-url.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import type { AssistantEntry } from "../assistant-config.js";
+import { resolveRuntimeMigrationUrl } from "../runtime-url.js";
+
+function makeEntry(
+  overrides: Partial<AssistantEntry> & {
+    cloud: string;
+    runtimeUrl: string;
+    assistantId: string;
+  },
+): Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId"> {
+  return {
+    cloud: overrides.cloud,
+    runtimeUrl: overrides.runtimeUrl,
+    assistantId: overrides.assistantId,
+  };
+}
+
+describe("resolveRuntimeMigrationUrl", () => {
+  test("local cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "local",
+      runtimeUrl: "http://localhost:7821",
+      assistantId: "ast-local-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://localhost:7821/v1/migrations/export-to-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
+      "http://localhost:7821/v1/migrations/import-from-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-abc")).toBe(
+      "http://localhost:7821/v1/migrations/jobs/job-abc",
+    );
+  });
+
+  test("docker cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "docker",
+      runtimeUrl: "http://localhost:7831",
+      assistantId: "ast-docker-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://localhost:7831/v1/migrations/export-to-gcs",
+    );
+  });
+
+  test("vellum (platform-managed) cloud uses wildcard-proxy /v1/assistants/<id>/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "vellum",
+      runtimeUrl: "https://platform.vellum.ai",
+      assistantId: "11111111-2222-3333-4444-555555555555",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/export-to-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/import-from-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-xyz")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/jobs/job-xyz",
+    );
+  });
+
+  test("dev platform URL still routes through the wildcard prefix", () => {
+    const entry = makeEntry({
+      cloud: "vellum",
+      runtimeUrl: "https://dev-platform.vellum.ai",
+      assistantId: "ast-dev-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "https://dev-platform.vellum.ai/v1/assistants/ast-dev-1/migrations/export-to-gcs",
+    );
+  });
+
+  test("a non-vellum, non-local cloud (e.g. gcp) uses the local-shape URL", () => {
+    const entry = makeEntry({
+      cloud: "gcp",
+      runtimeUrl: "http://10.0.0.5:7821",
+      assistantId: "ast-gcp-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://10.0.0.5:7821/v1/migrations/export-to-gcs",
+    );
+  });
+});

package/src/lib/__tests__/terminal-session.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  parseSentinelOutput,
+  stripAnsi,
+} from "../terminal-session.js";
+
+const START = "__VELLUM_EXEC_START_1234__";
+const END = "__VELLUM_EXEC_END_1234__";
+
+// ---------------------------------------------------------------------------
+// stripAnsi
+// ---------------------------------------------------------------------------
+
+describe("stripAnsi", () => {
+  test("removes SGR color codes", () => {
+    expect(stripAnsi("\x1b[32mINFO\x1b[39m hello")).toBe("INFO hello");
+  });
+
+  test("removes OSC title sequences", () => {
+    expect(stripAnsi("\x1b]0;title\x07prompt$ ")).toBe("prompt$ ");
+  });
+
+  test("removes carriage returns", () => {
+    expect(stripAnsi("line1\r\nline2\r\n")).toBe("line1\nline2\n");
+  });
+
+  test("removes bracket-paste mode escapes", () => {
+    expect(stripAnsi("\x1b[?2004hroot$ ")).toBe("root$ ");
+  });
+
+  test("removes charset designator sequences", () => {
+    expect(stripAnsi("\x1b(Bhello")).toBe("hello");
+  });
+
+  test("passes through plain text unchanged", () => {
+    expect(stripAnsi("just plain text")).toBe("just plain text");
+  });
+
+  test("handles mixed ANSI sequences", () => {
+    const raw =
+      "\x1b[?2004hroot:/workspace$ \r\x1b[K\rroot:/workspace$ echo hello\r\nhello\r\n";
+    const clean = stripAnsi(raw);
+    expect(clean).not.toContain("\x1b");
+    expect(clean).not.toContain("\r");
+    expect(clean).toContain("hello");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseSentinelOutput
+// ---------------------------------------------------------------------------
+
+describe("parseSentinelOutput", () => {
+  test("extracts output between sentinels", () => {
+    const cleaned = [
+      `echo '${START}'; ls; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      "file1.txt",
+      "file2.txt",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("file1.txt\nfile2.txt");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("extracts non-zero exit code", () => {
+    const cleaned = [
+      `echo '${START}'; false; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      END,
+      "__VELLUM_EXIT_1",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("");
+    expect(result.exitCode).toBe(1);
+  });
+
+  test("handles exit code 127 (command not found)", () => {
+    const cleaned = [
+      START,
+      "bash: nosuchcmd: command not found",
+      END,
+      "__VELLUM_EXIT_127",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("bash: nosuchcmd: command not found");
+    expect(result.exitCode).toBe(127);
+  });
+
+  test("uses last start sentinel (skips command echo)", () => {
+    // The command echo contains the sentinel text, then the actual output
+    // sentinel comes later. Parser must pick the last START, not the echo.
+    const cleaned = [
+      `root$ echo '${START}'; mycommand; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      "real output here",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("real output here");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("regression: end sentinel in echo before start sentinel in output", () => {
+    // This was the original bug: backward search found END in the echo
+    // (line 0) before START in the output (line 1), giving endIdx < startIdx.
+    const cleaned = [
+      `echo '${START}'; cmd; echo '${END}'; echo '__VELLUM_EXIT_'$__ec; exit $__ec`,
+      START,
+      "[INFO] Running clawhub command",
+      '    args: ["search"]',
+      '    cwd: "/workspace"',
+    ].join("\n");
+
+    // No end sentinel in actual output yet (stream was cut short in old code)
+    const result = parseSentinelOutput(cleaned, START, END);
+    // Should still return the partial output (no end sentinel → take everything)
+    expect(result.output).toContain("[INFO] Running clawhub command");
+    expect(result.output).toContain('cwd: "/workspace"');
+  });
+
+  test("handles multiline output with special characters", () => {
+    const cleaned = [
+      START,
+      "📤 Resend Email Setup [installed]",
+      "  ID: resend-setup",
+      '  Set up and send emails via a user-provided Resend account (BYO email provider)',
+      "",
+      "Community registry (1):",
+      "",
+      "  resend-setup [installed]",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toContain("📤 Resend Email Setup");
+    expect(result.output).toContain("Community registry (1):");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("returns empty output and exit code 0 when no sentinels found", () => {
+    const cleaned = "just some random output\nwith no sentinels\n";
+    const result = parseSentinelOutput(cleaned, START, END);
+    // Falls back to entire output (trimmed)
+    expect(result.output).toBe(
+      "just some random output\nwith no sentinels",
+    );
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("handles output with only start sentinel (no end)", () => {
+    const cleaned = [
+      START,
+      "partial output",
+      "more output",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("partial output\nmore output");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("handles real-world verbose trace structure", () => {
+    // Simulates the full cleaned output from a real exec session
+    const cleaned = [
+      "root:/workspace$ root:/workspace$ " +
+        `echo '${START}'; 'assistant' 'skills' 'search' 'resend-setup'; __ec=$?; echo ` +
+        ` '${END}'; echo '__VELLUM_EXIT_'$__ec; exit $__ec`,
+      START,
+      "[13:06:38.851] INFO (761 on pod-0): [clawhub] Running clawhub command",
+      '    args: [',
+      '      "search",',
+      '      "resend-setup",',
+      '      "--limit",',
+      '      "10"',
+      "    ]",
+      '    cwd: "/workspace"',
+      "Bundled & installed skills (1):",
+      "",
+      "  📤 Resend Email Setup [installed]",
+      "    ID: resend-setup",
+      "",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toContain("Bundled & installed skills (1):");
+    expect(result.output).toContain("📤 Resend Email Setup [installed]");
+    expect(result.output).toContain("[clawhub] Running clawhub command");
+    expect(result.exitCode).toBe(0);
+  });
+});