@united-workforce/cli 0.4.0 → 0.5.0

package/src/__tests__/store-unified-threads.test.ts

@@ -1,23 +1,17 @@
-import { mkdir, mkdtemp } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
-import { describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import {
   completeThread,
-  createUwfStore,
+  type createUwfStore,
   getThread,
   loadActiveThreads,
   loadHistoryThreads,
   setThread,
 } from "../store.js";
-
-async function makeUwfStore(storageRoot: string) {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 async function seedThreadHead(
   uwf: Awaited<ReturnType<typeof createUwfStore>>,
@@ -26,9 +20,25 @@ async function seedThreadHead(
   return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
 }
 
+let tmpDir: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-store-test-"));
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
 describe("unified thread storage", () => {
   test("loadActiveThreads excludes completed threads", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-active-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000ACTIVE1" as ThreadId;
@@ -59,7 +69,6 @@ describe("unified thread storage", () => {
   });
 
   test("loadActiveThreads excludes cancelled threads", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-active-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000ACTIVE3" as ThreadId;
@@ -90,7 +99,6 @@ describe("unified thread storage", () => {
   });
 
   test("loadHistoryThreads only returns completed and cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-history-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000HISTOR1" as ThreadId;
@@ -132,7 +140,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread marks thread as completed", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE1" as ThreadId;
     const head = await seedThreadHead(uwf, "active-head");
@@ -155,7 +162,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread marks thread as cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE2" as ThreadId;
     const head = await seedThreadHead(uwf, "active-head");
@@ -178,7 +184,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread clears suspend metadata", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE3" as ThreadId;
     const head = await seedThreadHead(uwf, "suspended-head");
@@ -201,7 +206,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread handles non-existent thread gracefully", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000NOEXIST" as ThreadId;
 
@@ -213,7 +217,6 @@ describe("unified thread storage", () => {
   });
 
   test("status and completedAt tags are persisted and loaded", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-tags-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000TAGTEST" as ThreadId;
     const head = await seedThreadHead(uwf, "test-head");

package/src/__tests__/thread-cancel-status.test.ts

@@ -1,22 +1,16 @@
-import { mkdir, mkdtemp } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
-import { describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import {
   completeThread,
-  createUwfStore,
+  type createUwfStore,
   getThread,
   loadHistoryThreads,
   setThread,
 } from "../store.js";
-
-async function makeUwfStore(storageRoot: string) {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 async function seedHistoryHead(
   uwf: Awaited<ReturnType<typeof createUwfStore>>,
@@ -25,9 +19,25 @@ async function seedHistoryHead(
   return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
 }
 
+let tmpDir: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
 describe("thread cancel status", () => {
   test("cancelled thread has status 'cancelled'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const threadId = "01JTEST000000000000CANCEL1" as ThreadId;
     const uwf = await makeUwfStore(tmpDir);
     const head = await seedHistoryHead(uwf, "cancelled-head");
@@ -48,7 +58,6 @@ describe("thread cancel status", () => {
   });
 
   test("completed thread has status 'completed'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const threadId = "01JTEST000000000000CANCEL2" as ThreadId;
     const uwf = await makeUwfStore(tmpDir);
     const head = await seedHistoryHead(uwf, "completed-head");
@@ -69,7 +78,6 @@ describe("thread cancel status", () => {
   });
 
   test("loadHistoryThreads returns completed and cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const head1 = await seedHistoryHead(uwf, "head1");
     const head2 = await seedHistoryHead(uwf, "head2");
@@ -103,7 +111,6 @@ describe("thread cancel status", () => {
   });
 
   test("mixed completed and cancelled entries preserve distinct statuses", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const head1 = await seedHistoryHead(uwf, "head1");
     const head2 = await seedHistoryHead(uwf, "head2");

package/src/__tests__/thread-cancel-text-renderer.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "vitest";
+import { formatOutput, getTextRenderer, TEXT_RENDERERS } from "../format.js";
+import { renderThreadCancel } from "../text-renderers.js";
+
+describe("thread cancel — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'thread cancel'", () => {
+    expect(getTextRenderer("thread cancel")).toBeDefined();
+    expect(typeof getTextRenderer("thread cancel")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['thread cancel'] is the same reference as renderThreadCancel", () => {
+    expect(TEXT_RENDERERS["thread cancel"]).toBe(renderThreadCancel);
+  });
+
+  test("renderThreadCancel is exported from text-renderers.ts", () => {
+    expect(typeof renderThreadCancel).toBe("function");
+  });
+});
+
+describe("renderThreadCancel — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes the cancelled thread's ULID", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(out).toContain("01JTEST000000000000CANCEL1");
+  });
+
+  test("indicates cancelled status (Status: cancelled OR Cancelled: yes)", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    // accept either rendering style
+    const lower = out.toLowerCase();
+    const hasCancelMarker = lower.includes("cancelled") || lower.includes("yes");
+    expect(hasCancelMarker).toBe(true);
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("renderThreadCancel — partial / missing data", () => {
+  test("missing 'cancelled' field — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({ thread: "01JTEST000000000000CANCEL1" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("missing 'thread' field — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({ cancelled: true });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty object — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({});
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, no throw", () => {
+    expect(() => renderThreadCancel(null)).not.toThrow();
+    const out = renderThreadCancel(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-object payload (string) — returns string, no throw", () => {
+    expect(() => renderThreadCancel("oops")).not.toThrow();
+    const out = renderThreadCancel("oops");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("formatOutput integration — thread cancel", () => {
+  test("formatOutput(data, 'text', 'thread cancel') uses renderer", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "text", "thread cancel");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out).toContain("01JTEST000000000000CANCEL1");
+  });
+
+  test("formatOutput(data, 'json', 'thread cancel') still emits parseable JSON", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "json", "thread cancel");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'thread cancel') still emits YAML", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "yaml", "thread cancel");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("thread:");
+    expect(out).toContain("cancelled:");
+  });
+});

package/src/__tests__/thread-list-filters.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
@@ -16,17 +16,10 @@ import {
   saveWorkflowRegistry,
   setThread,
 } from "../store.js";
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
-async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  // Set OCAS_HOME to use the test's CAS directory
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
-
 async function createTestWorkflow(uwf: UwfStore): Promise<CasRef> {
   const workflowPayload = {
     name: "test-workflow",
@@ -84,12 +77,19 @@ async function completeThread(
 // ── test setup ────────────────────────────────────────────────────────────────
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "thread-list-filters-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });
 

package/src/__tests__/thread-list-template-ms-date.test.ts

@@ -0,0 +1,110 @@
+import { OUTPUT_TEMPLATES } from "@united-workforce/protocol";
+import { Liquid } from "liquidjs";
+import { describe, expect, test } from "vitest";
+
+/**
+ * Issue #351 — `uwf thread list --format text` rendered the `STARTED` column
+ * as `58414-12-06` because `THREAD_LIST_TEMPLATE` piped `item.startedAt` (Unix
+ * **ms** per `THREAD_LIST_OUTPUT_SCHEMA`) directly into LiquidJS's `| date`
+ * filter, which expects Unix **seconds**.
+ *
+ * This integration test renders the template against a known ms timestamp
+ * and asserts the year falls within the realistic 20xx range, confirming
+ * the ms→s conversion is in place at the protocol layer.
+ */
+
+function makeEngine(): Liquid {
+  return new Liquid({ cache: false, strictFilters: false, strictVariables: false });
+}
+
+describe("THREAD_LIST_TEMPLATE rendering — issue #351 ms→s for `| date`", () => {
+  test("renders item.startedAt=1781229932779 as a 2026 calendar date (not 58414)", async () => {
+    const engine = makeEngine();
+    const out = await engine.parseAndRender(OUTPUT_TEMPLATES["thread-list"], {
+      items: [
+        {
+          threadId: "01K5HMKZQB7VDA8E2K9P3R5XBC",
+          workflowHash: "WF1234567890A",
+          workflowName: null,
+          status: "idle",
+          currentRole: "planner",
+          startedAt: 1781229932779,
+          completedAt: null,
+        },
+      ],
+    });
+
+    expect(out).not.toContain("58414");
+    expect(out).toMatch(/\b20\d{2}-\d{2}-\d{2}\b/);
+    // The STARTED cell must NOT begin with a 5-digit year.
+    expect(out).not.toMatch(/\b\d{5}-\d{2}-\d{2}\b/);
+  });
+
+  test("renders `-` for items with startedAt=null (null guard preserved)", async () => {
+    const engine = makeEngine();
+    const out = await engine.parseAndRender(OUTPUT_TEMPLATES["thread-list"], {
+      items: [
+        {
+          threadId: "01K5HMKZQB7VDA8E2K9P3R5XBC",
+          workflowHash: "WF1234567890A",
+          workflowName: null,
+          status: "idle",
+          currentRole: "planner",
+          startedAt: null,
+          completedAt: null,
+        },
+      ],
+    });
+
+    expect(out).not.toContain("58414");
+    expect(out).not.toContain("Invalid Date");
+    expect(out).not.toContain("1970-01-01");
+    // Last token of the row is the rendered STARTED cell — must be `-`.
+    const dataRow = out
+      .split("\n")
+      .find((line: string) => line.includes("01K5HMKZQB7VDA8E2K9P3R5XBC"));
+    expect(dataRow).toBeDefined();
+    expect(dataRow?.trimEnd().endsWith("-")).toBe(true);
+  });
+
+  test("renders multiple ms timestamps across years 2020–2030 with correct year prefix", async () => {
+    const engine = makeEngine();
+    const items = [
+      {
+        threadId: "ID1",
+        workflowHash: "WF",
+        workflowName: null,
+        status: "idle",
+        currentRole: null,
+        startedAt: Date.UTC(2020, 0, 1, 0, 0, 0),
+        completedAt: null,
+      },
+      {
+        threadId: "ID2",
+        workflowHash: "WF",
+        workflowName: null,
+        status: "idle",
+        currentRole: null,
+        startedAt: Date.UTC(2026, 5, 12, 5, 25, 0),
+        completedAt: null,
+      },
+      {
+        threadId: "ID3",
+        workflowHash: "WF",
+        workflowName: null,
+        status: "idle",
+        currentRole: null,
+        startedAt: Date.UTC(2030, 11, 31, 23, 59, 0),
+        completedAt: null,
+      },
+    ];
+
+    const out = await engine.parseAndRender(OUTPUT_TEMPLATES["thread-list"], { items });
+
+    expect(out).toContain("2020-");
+    expect(out).toContain("2026-");
+    expect(out).toContain("2030-");
+    expect(out).not.toContain("58414");
+    expect(out).not.toMatch(/\b\d{5}-\d{2}-\d{2}\b/);
+  });
+});

package/src/__tests__/thread-list-workflow-corrupt.test.ts

@@ -0,0 +1,198 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CasRef, ThreadId } from "@united-workforce/protocol";
+import { createThreadIndexEntry } from "@united-workforce/protocol";
+import { generateUlid } from "@united-workforce/util";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { cmdThreadList } from "../commands/thread.js";
+import type { UwfStore } from "../store.js";
+import { completeThread as completeThreadInStore, setThread } from "../store.js";
+import { makeUwfStore } from "./thread-test-helpers.js";
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+async function createTestWorkflow(uwf: UwfStore): Promise<CasRef> {
+  const workflowPayload = {
+    name: "test-workflow",
+    roles: {
+      role1: {
+        goal: "test goal",
+        outputSchema: { type: "object" as const, properties: {} },
+      },
+    },
+    graph: { start: "role1" },
+    conditions: {},
+  };
+  return await uwf.store.cas.put(uwf.schemas.workflow, workflowPayload);
+}
+
+async function createTestThread(
+  uwf: UwfStore,
+  storageRoot: string,
+  workflowHash: CasRef,
+  timestamp: number,
+): Promise<ThreadId> {
+  const threadId = generateUlid(timestamp) as ThreadId;
+  const startPayload = {
+    workflow: workflowHash,
+    prompt: "test prompt",
+    cwd: storageRoot,
+  };
+  const headHash = await uwf.store.cas.put(uwf.schemas.startNode, startPayload);
+  setThread(uwf.varStore, threadId, createThreadIndexEntry(headHash));
+  return threadId;
+}
+
+// ── test setup ────────────────────────────────────────────────────────────────
+
+let tmpDir: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "thread-list-workflow-corrupt-test-"));
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+// ── issue #326: loadWorkflowPayload throws instead of process.exit ───────────
+
+describe("loadWorkflowPayload throws on error (#326)", () => {
+  test("active thread with missing workflow CAS node appears as corrupt", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const workflowHash = await createTestWorkflow(uwf);
+    const now = Date.now();
+
+    // Create a valid thread
+    const validId = await createTestThread(uwf, tmpDir, workflowHash, now);
+
+    // Create a thread with a different workflow, then delete it
+    const otherWorkflowPayload = {
+      name: "other-workflow",
+      roles: {
+        role1: {
+          goal: "other goal",
+          outputSchema: { type: "object" as const, properties: {} },
+        },
+      },
+      graph: { start: "role1" },
+      conditions: {},
+    };
+    const otherWorkflowHash = await uwf.store.cas.put(uwf.schemas.workflow, otherWorkflowPayload);
+    const corruptId = await createTestThread(uwf, tmpDir, otherWorkflowHash, now + 1000);
+
+    // Delete the other workflow CAS node — start node still exists but workflow ref dangles
+    uwf.store.cas.delete(otherWorkflowHash);
+
+    // thread list should NOT crash — corrupt thread appears with status: "corrupt"
+    const result = await cmdThreadList(tmpDir, null, null, null, null, null, true);
+
+    expect(result.length).toBe(2);
+
+    const validItem = result.find((r) => r.thread === validId);
+    expect(validItem).toBeDefined();
+    expect(validItem!.status).toBe("idle");
+
+    const corruptItem = result.find((r) => r.thread === corruptId);
+    expect(corruptItem).toBeDefined();
+    expect(corruptItem!.status).toBe("corrupt");
+    expect(corruptItem!.statusDisplay).toBe("corrupt");
+  });
+
+  test("active thread with wrong-type workflow CAS node appears as corrupt", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const now = Date.now();
+
+    // Create a valid workflow and thread
+    const workflowHash = await createTestWorkflow(uwf);
+    const validId = await createTestThread(uwf, tmpDir, workflowHash, now);
+
+    // Create a non-workflow CAS node (text type) and use its hash as a workflow ref
+    const wrongTypeHash = await uwf.store.cas.put(uwf.schemas.text, "not a workflow");
+
+    // Create a thread whose start node points to the wrong-type CAS node
+    const corruptId = generateUlid(now + 1000) as ThreadId;
+    const startPayload = {
+      workflow: wrongTypeHash,
+      prompt: "corrupt thread with wrong type workflow",
+      cwd: tmpDir,
+    };
+    const headHash = await uwf.store.cas.put(uwf.schemas.startNode, startPayload);
+    setThread(uwf.varStore, corruptId, createThreadIndexEntry(headHash));
+
+    // thread list should NOT crash — wrong-type thread appears as corrupt
+    const result = await cmdThreadList(tmpDir, null, null, null, null, null, true);
+
+    expect(result.length).toBe(2);
+
+    const validItem = result.find((r) => r.thread === validId);
+    expect(validItem).toBeDefined();
+    expect(validItem!.status).toBe("idle");
+
+    const corruptItem = result.find((r) => r.thread === corruptId);
+    expect(corruptItem).toBeDefined();
+    expect(corruptItem!.status).toBe("corrupt");
+    expect(corruptItem!.statusDisplay).toBe("corrupt");
+  });
+
+  test("completed thread with missing workflow CAS node retains stored status with --all", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const now = Date.now();
+
+    // Create two separate workflows so we can corrupt one without affecting the other
+    const activeWorkflowHash = await createTestWorkflow(uwf);
+    const completedWorkflowPayload = {
+      name: "completed-workflow",
+      roles: {
+        role1: {
+          goal: "completed goal",
+          outputSchema: { type: "object" as const, properties: {} },
+        },
+      },
+      graph: { start: "role1" },
+      conditions: {},
+    };
+    const completedWorkflowHash = await uwf.store.cas.put(
+      uwf.schemas.workflow,
+      completedWorkflowPayload,
+    );
+
+    // Create a valid active thread
+    const activeId = await createTestThread(uwf, tmpDir, activeWorkflowHash, now);
+
+    // Create a thread and complete it
+    const completedId = await createTestThread(uwf, tmpDir, completedWorkflowHash, now + 1000);
+    completeThreadInStore(uwf.varStore, completedId, "end");
+
+    // Delete only the completed thread's workflow CAS node
+    uwf.store.cas.delete(completedWorkflowHash);
+
+    // thread list --all should NOT crash
+    const result = await cmdThreadList(tmpDir, null, null, null, null, null, true);
+
+    expect(result.length).toBe(2);
+
+    // Active thread is still valid (its workflow exists)
+    const activeItem = result.find((r) => r.thread === activeId);
+    expect(activeItem).toBeDefined();
+    expect(activeItem!.status).toBe("idle");
+
+    // Completed thread retains its stored status — collectCompletedThreads only calls
+    // resolveWorkflowFromHead (returns ref from start node) and never loads the workflow CAS node
+    const completedItem = result.find((r) => r.thread === completedId);
+    expect(completedItem).toBeDefined();
+    expect(completedItem!.status).toBe("end");
+    expect(completedItem!.statusDisplay).toBe("end");
+    // workflowName is null because the workflow ref won't match a registry entry
+    // (the deleted workflow was never registered)
+    expect(completedItem!.workflowName).toBeNull();
+  });
+});