@united-workforce/cli 0.4.0 → 0.6.0

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-join.test.ts

@@ -0,0 +1,103 @@
+import { mkdir, 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 { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  createMarker,
+  deleteMarker,
+  getProcessStartTime,
+  isThreadRunning,
+} from "../background/index.js";
+import { cmdThreadJoin } from "../commands/thread.js";
+import { makeUwfStore, seedThread } from "./thread-test-helpers.js";
+
+describe("cmdThreadJoin", () => {
+  let storageRoot: string;
+  let savedOcasHome: string | undefined;
+
+  beforeEach(async () => {
+    savedOcasHome = process.env.OCAS_HOME;
+    storageRoot = join(
+      tmpdir(),
+      `uwf-test-join-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    await mkdir(storageRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    if (savedOcasHome !== undefined) {
+      process.env.OCAS_HOME = savedOcasHome;
+    } else {
+      delete process.env.OCAS_HOME;
+    }
+    await rm(storageRoot, { recursive: true, force: true });
+  });
+
+  it("throws when thread does not exist", async () => {
+    await makeUwfStore(storageRoot);
+    const threadId = "01JF0000000000NOTEXIST0" as ThreadId;
+    await expect(cmdThreadJoin(storageRoot, threadId, null)).rejects.toThrow(
+      /thread not found|process\.exit/,
+    );
+  });
+
+  it("times out when thread keeps running", async () => {
+    const threadId = "01JF0000000000TESTJOIN03" as ThreadId;
+    await makeUwfStore(storageRoot);
+    // Seed a thread so existence check passes
+    const uwf = await makeUwfStore(storageRoot);
+    const head = (await uwf.store.cas.put(uwf.schemas.text, "join-timeout-test")) as CasRef;
+    await seedThread(storageRoot, threadId, createThreadIndexEntry(head));
+
+    // Create a running marker with our PID (it will stay alive)
+    await createMarker(storageRoot, {
+      thread: threadId,
+      workflow: "AAAAAAAAAAAAA" as CasRef,
+      pid: process.pid,
+      startedAt: Date.now(),
+      processStartTime: getProcessStartTime(process.pid),
+    });
+
+    // Timeout after 100ms — should fail because marker never disappears
+    await expect(cmdThreadJoin(storageRoot, threadId, 100)).rejects.toThrow(
+      /join timed out|process\.exit/,
+    );
+
+    // Cleanup
+    await deleteMarker(storageRoot, threadId);
+  });
+
+  it("poll loop exits when marker is removed", async () => {
+    const threadId = "01JF0000000000TESTJOIN04" as ThreadId;
+    const uwf = await makeUwfStore(storageRoot);
+    const head = (await uwf.store.cas.put(uwf.schemas.text, "join-poll-test")) as CasRef;
+    await seedThread(storageRoot, threadId, createThreadIndexEntry(head));
+
+    // Create a running marker
+    await createMarker(storageRoot, {
+      thread: threadId,
+      workflow: "AAAAAAAAAAAAA" as CasRef,
+      pid: process.pid,
+      startedAt: Date.now(),
+      processStartTime: getProcessStartTime(process.pid),
+    });
+
+    // Confirm marker is valid
+    expect(await isThreadRunning(storageRoot, threadId)).not.toBeNull();
+
+    // Remove it after a short delay — simulates background worker finishing
+    setTimeout(() => {
+      deleteMarker(storageRoot, threadId);
+    }, 300);
+
+    // cmdThreadJoin will poll and wait. It will exit the poll loop after marker
+    // disappears, then try to resolve workflow from head. Our simple text node
+    // won't resolve, so it will fail — but the key test is that the poll loop
+    // DID exit (it didn't time out). We use a generous timeout to prove this.
+    await expect(cmdThreadJoin(storageRoot, threadId, 5000)).rejects.toThrow(
+      /failed to resolve workflow|process\.exit/,
+    );
+  });
+});

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();
+  });
+});

package/src/__tests__/thread-poke.test.ts

@@ -28,12 +28,19 @@ const OUTPUT_SCHEMA = {
 const THREAD_ID = "01POKESTEPTEST00000000" as ThreadId;
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-poke-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });
 
@@ -271,8 +278,10 @@ function runUwf(
   casDir: string,
 ): { stdout: string; stderr: string; status: number } {
   const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "dist", "cli.js");
+  // Tests parse stdout as bare JSON; default --format text would break that.
+  const formatArgs = args.includes("--format") ? args : ["--format", "raw-json", ...args];
   try {
-    const stdout = execFileSync(process.execPath, [cliPath, ...args], {
+    const stdout = execFileSync(process.execPath, [cliPath, ...formatArgs], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -529,7 +538,7 @@ describe("uwf thread poke - edge cases", () => {
     expect(cliOutput.suspendMessage).toBeNull();
   });
 
-  test("6.2 agent failure leaves thread head unchanged", async () => {
+  test("6.2 agent failure leaves thread head unchanged and suspends thread", async () => {
     const { casDir, oldStepHash, failingAgentPath } = await setupThread();
     const result = runUwf(
       ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", failingAgentPath],
@@ -541,5 +550,8 @@ describe("uwf thread poke - edge cases", () => {
     const uwf = await createUwfStore(tmpDir);
     const entry = getThread(uwf.varStore, THREAD_ID);
     expect(entry?.head).toBe(oldStepHash);
+    expect(entry?.status).toBe("suspended");
+    expect(entry?.suspendedRole).toBe("worker");
+    expect(entry?.suspendMessage).toContain("agent command failed");
   });
 });

package/src/__tests__/thread-read-xml-tags.test.ts

@@ -1,13 +1,11 @@
-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 { bootstrap, putSchema, type Store } from "@ocas/core";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { cmdThreadRead, THREAD_READ_DEFAULT_QUOTA } from "../commands/thread.js";
-import type { UwfStore } from "../store.js";
-import { createUwfStore } from "../store.js";
-import { seedThreads } from "./thread-test-helpers.js";
+import { makeUwfStore, seedThreads } from "./thread-test-helpers.js";
 
 // ── schemas used in tests ────────────────────────────────────────────────────
 
@@ -49,13 +47,6 @@ const DETAIL_SCHEMA = {
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
-async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
-
 async function registerDetailSchemas(store: Store) {
   await bootstrap(store);
   const [turn, detail] = await Promise.all([
@@ -68,12 +59,19 @@ async function registerDetailSchemas(store: Store) {
 // ── fixture ───────────────────────────────────────────────────────────────────
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });