@united-workforce/cli 0.3.0 → 0.5.0

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

@@ -27,12 +27,19 @@ const SUSPEND_MESSAGE = "Please clarify: Which API?";
 type MockAgentMode = "suspend" | "ok";
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-resume-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });
 
@@ -75,11 +82,6 @@ async function setupSuspendedThread(mode: MockAgentMode): Promise<{
         resume: { role: "worker", prompt: "Resume the work", location: null },
       },
       worker: {
-        needs_input: {
-          role: "$SUSPEND",
-          prompt: "Please clarify: {{{question}}}",
-          location: null,
-        },
         ok: { role: "reviewer", prompt: "Review the work", location: null },
       },
       reviewer: { done: { role: "$END", prompt: "Done", location: null } },
@@ -95,9 +97,9 @@ async function setupSuspendedThread(mode: MockAgentMode): Promise<{
   process.env.OCAS_HOME = casDir;
   await seedThreads(tmpDir, { [THREAD_ID]: startHash });
 
-  const outputHash = await store.cas.put(outputSchemaHash, {
-    $status: "needs_input",
-    question: "Which API?",
+  const outputHash = await store.cas.put(schemas.suspendOutput, {
+    $status: "$SUSPEND",
+    reason: SUSPEND_MESSAGE,
   });
   const detailHash = await store.cas.put(schemas.text, "mock detail");
 
@@ -132,14 +134,15 @@ async function setupSuspendedThread(mode: MockAgentMode): Promise<{
   const mockAgentPath = join(tmpDir, "mock-agent.sh");
 
   const frontmatter =
-    mode === "suspend" ? { $status: "needs_input", question: "Which API?" } : { $status: "ok" };
+    mode === "suspend" ? { $status: "$SUSPEND", reason: SUSPEND_MESSAGE } : { $status: "ok" };
+  const frontmatterSchema = mode === "suspend" ? schemas.suspendOutput : outputSchemaHash;
 
   const adapterJson = JSON.stringify({
     stepHash: await store.cas.put(schemas.stepNode, {
       start: startHash,
       prev: stepHash,
       role: "worker",
-      output: await store.cas.put(outputSchemaHash, frontmatter),
+      output: await store.cas.put(frontmatterSchema, frontmatter),
       detail: detailHash,
       agent: "uwf-mock",
       edgePrompt: "resume prompt placeholder",
@@ -177,7 +180,7 @@ echo '${adapterJson}'
   const configPath = join(tmpDir, "config.yaml");
   await writeFile(
     configPath,
-    `defaultAgent: uwf-hermes\ndefaultModel: test-model\nagentOverrides: null\nagents: {}\nproviders: {}\nmodels: {}\n`,
+    `defaultAgent: uwf-hermes\nagentOverrides: null\nagents:\n  uwf-hermes:\n    command: uwf-hermes\n`,
   );
 
   return { casDir, mockAgentPath, promptCapturePath };
@@ -188,8 +191,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: {
@@ -338,7 +343,7 @@ describe("uwf thread resume", () => {
     }
   });
 
-  test("multiple suspend/resume cycles", async () => {
+  test("multiple suspend/resume cycles", { timeout: 15_000 }, async () => {
     const originalCasDir = process.env.OCAS_HOME;
     const { casDir, mockAgentPath, promptCapturePath } = await setupSuspendedThread("suspend");
     process.env.OCAS_HOME = casDir;
@@ -537,7 +542,7 @@ describe("uwf thread resume - completed threads", () => {
     await seedThreads(tmpDir, {
       [THREAD_ID]: {
         head: reviewerStepHash,
-        status: "completed",
+        status: "end",
         suspendedRole: null,
         suspendMessage: null,
         completedAt: 1716600002000,
@@ -599,7 +604,7 @@ echo '${adapterJson}'
     const configPath = join(tmpDir, "config.yaml");
     await writeFile(
       configPath,
-      `defaultAgent: uwf-hermes\ndefaultModel: test-model\nagentOverrides: null\nagents: {}\nproviders: {}\nmodels: {}\n`,
+      `defaultAgent: uwf-hermes\nagentOverrides: null\nagents:\n  uwf-hermes:\n    command: uwf-hermes\n`,
     );
 
     const result = runUwf(

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

@@ -1,21 +1,12 @@
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { putSchema } from "@ocas/core";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
 import { describe, expect, test } from "vitest";
-import { createMarker, deleteMarker } from "../background/index.js";
+import { createMarker, deleteMarker, getProcessStartTime } from "../background/index.js";
 import { cmdThreadShow, cmdThreadStart } from "../commands/thread.js";
 import { completeThread, createUwfStore, loadAllThreads, setThread } from "../store.js";
 
-const OUTPUT_SCHEMA = {
-  type: "object" as const,
-  properties: {
-    $status: { type: "string" as const },
-    question: { type: "string" as const },
-  },
-};
-
 const TEST_WORKFLOW_YAML = `
 name: test-status
 description: Test workflow for status field
@@ -59,15 +50,12 @@ roles:
     capabilities: ["coding"]
     procedure: Work
     output: |
-      $status: "needs_input"
-      question: "Which API?"
+      $status: "done"
     frontmatter:
-      oneOf:
-        - type: object
-          required: ["$status", "question"]
-          properties:
-            $status: { const: "needs_input" }
-            question: { type: string }
+      type: object
+      required: ["$status"]
+      properties:
+        $status: { const: "done" }
 graph:
   $START:
     new:
@@ -79,9 +67,9 @@ graph:
       prompt: "Resume work"
       location: null
   worker:
-    needs_input:
-      role: $SUSPEND
-      prompt: "Please clarify: {{{question}}}"
+    done:
+      role: $END
+      prompt: "Done"
       location: null
 `;
 
@@ -97,8 +85,7 @@ async function insertStepNode(
   if (headEntry === undefined) throw new Error(`thread ${threadId} not in index`);
   const head = headEntry.head;
 
-  const outputSchemaHash = await putSchema(uwf.store, OUTPUT_SCHEMA);
-  const outputHash = await uwf.store.cas.put(outputSchemaHash, outputPayload);
+  const outputHash = await uwf.store.cas.put(uwf.schemas.suspendOutput, outputPayload);
   const detailHash = await uwf.store.cas.put(uwf.schemas.text, "detail-placeholder");
 
   const headNode = uwf.store.cas.get(head);
@@ -183,6 +170,7 @@ describe("thread show status field", () => {
       workflow,
       pid: process.pid,
       startedAt: Date.now(),
+      processStartTime: getProcessStartTime(process.pid),
     });
 
     try {
@@ -216,11 +204,11 @@ describe("thread show status field", () => {
     const head = index[threadId]!.head;
     if (!head) throw new Error("Thread not found in index");
 
-    completeThread(uwfForIndex.varStore, threadId, "completed");
+    completeThread(uwfForIndex.varStore, threadId, "end");
 
     const result = await cmdThreadShow(storageRoot, threadId);
 
-    expect(result.status).toBe("completed");
+    expect(result.status).toBe("end");
     expect(result.done).toBe(true);
     expect(result.background).toBe(null);
     expect(result.thread).toBe(threadId);
@@ -274,11 +262,11 @@ describe("thread show status field", () => {
     const head = index[threadId]!.head;
     if (!head) throw new Error("Thread not found in index");
 
-    completeThread(uwfForIndex.varStore, threadId, "completed");
+    completeThread(uwfForIndex.varStore, threadId, "end");
 
     const result = await cmdThreadShow(storageRoot, threadId);
 
-    expect(result.status).toBe("completed");
+    expect(result.status).toBe("end");
     expect(result.done).toBe(true);
     expect(result.background).toBe(null);
 
@@ -300,8 +288,8 @@ describe("thread show status field", () => {
       const threadId = startResult.thread as ThreadId;
 
       await insertStepNode(storageRoot, threadId, "worker", {
-        $status: "needs_input",
-        question: "Which API?",
+        $status: "$SUSPEND",
+        reason: "Please clarify: Which API?",
       });
 
       const result = await cmdThreadShow(storageRoot, threadId);

package/src/__tests__/thread-start-cwd-cli.test.ts

@@ -150,16 +150,28 @@ graph:
     // Verify CLI accepts --cwd option (no error thrown)
     const output = execFileSync(
       process.execPath,
-      [uwfBin, "thread", "start", "test-cwd-cli", "-p", "test prompt", "--cwd", testCwd],
+      [
+        uwfBin,
+        "--format",
+        "raw-json",
+        "thread",
+        "start",
+        "test-cwd-cli",
+        "-p",
+        "test prompt",
+        "--cwd",
+        testCwd,
+      ],
       {
         env: { ...process.env, UWF_HOME: storageRoot, OCAS_HOME: casDir },
         encoding: "utf8",
       },
     );
 
+    // raw-json envelope value for thread-start: { threadId, workflowHash }
     const result = JSON.parse(output);
-    expect(result.thread).toBeDefined();
-    expect(result.workflow).toBeDefined();
+    expect(result.threadId).toBeDefined();
+    expect(result.workflowHash).toBeDefined();
 
     // The fact that we got here without throwing means CLI accepted the --cwd option
     // The actual cwd functionality is tested by the other tests using cmdThreadStart directly

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

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

package/src/__tests__/thread-suspend-step.test.ts

@@ -62,13 +62,7 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
             new: { role: "worker", prompt: "Start work", location: null },
             resume: { role: "worker", prompt: "Resume work", location: null },
           },
-          worker: {
-            needs_input: {
-              role: "$SUSPEND",
-              prompt: "Please clarify: {{{question}}}",
-              location: null,
-            },
-          },
+          worker: {},
         },
       });
 
@@ -81,9 +75,9 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
       const threadId = "01SUSPENDSTEPTEST0000000" as ThreadId;
       await seedThreads(tmpDir, { [threadId]: startHash });
 
-      const outputHash = await store.cas.put(outputSchemaHash, {
-        $status: "needs_input",
-        question: "Which API?",
+      const outputHash = await store.cas.put(schemas.suspendOutput, {
+        $status: "$SUSPEND",
+        reason: "Please clarify: Which API?",
       });
       const detailHash = await store.cas.put(schemas.text, "mock detail");
 
@@ -109,7 +103,7 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
         stepHash,
         detailHash,
         role: "worker",
-        frontmatter: { $status: "needs_input", question: "Which API?" },
+        frontmatter: { $status: "$SUSPEND", reason: "Please clarify: Which API?" },
         body: "",
         startedAtMs,
         completedAtMs,
@@ -119,13 +113,13 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
       const configPath = join(tmpDir, "config.yaml");
       await writeFile(
         configPath,
-        `defaultAgent: uwf-hermes\ndefaultModel: test-model\nagentOverrides: null\nagents: {}\nproviders: {}\nmodels: {}\n`,
+        `defaultAgent: uwf-hermes\nagentOverrides: null\nagents:\n  uwf-hermes:\n    command: uwf-hermes\n`,
       );
 
       const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "dist", "cli.js");
       const stdout = execFileSync(
         process.execPath,
-        [cliPath, "thread", "exec", threadId, "--agent", mockAgentPath],
+        [cliPath, "--format", "raw-json", "thread", "exec", threadId, "--agent", mockAgentPath],
         {
           encoding: "utf8",
           stdio: ["ignore", "pipe", "pipe"],
@@ -139,7 +133,10 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
         },
       );
 
-      const cliOutput = JSON.parse(stdout.trim());
+      // thread exec envelope value: { threadId, workflowHash, steps: [...] }
+      const envelope = JSON.parse(stdout.trim());
+      expect(envelope.steps).toHaveLength(1);
+      const cliOutput = envelope.steps[0];
       expect(cliOutput.status).toBe("suspended");
       expect(cliOutput.head).toBe(stepHash);
       expect(cliOutput.suspendedRole).toBe("worker");
@@ -154,8 +151,8 @@ describe("suspend step CAS chain and threads.yaml metadata", () => {
 
       const outputNode = storeAfter.cas.get(outputHash);
       expect(outputNode?.payload).toEqual({
-        $status: "needs_input",
-        question: "Which API?",
+        $status: "$SUSPEND",
+        reason: "Please clarify: Which API?",
       });
 
       const { createUwfStore, getThread } = await import("../store.js");

package/src/__tests__/thread-suspended-display.test.ts

@@ -59,13 +59,7 @@ describe("suspended thread display", () => {
             new: { role: "worker", prompt: "Start work", location: null },
             resume: { role: "worker", prompt: "Resume work", location: null },
           },
-          worker: {
-            needs_input: {
-              role: "$SUSPEND",
-              prompt: "Please provide more details: {{{question}}}",
-              location: null,
-            },
-          },
+          worker: {},
         },
       });
 
@@ -77,9 +71,9 @@ describe("suspended thread display", () => {
 
       // Create suspended thread
       const suspendedThreadId = "01SUSPENDEDTHREAD0000000" as ThreadId;
-      const outputHash = await uwf.store.cas.put(outputSchemaHash, {
-        $status: "needs_input",
-        question: "What is the target API?",
+      const outputHash = await uwf.store.cas.put(uwf.schemas.suspendOutput, {
+        $status: "$SUSPEND",
+        reason: "Please provide more details: What is the target API?",
       });
       const detailHash = await uwf.store.cas.put(uwf.schemas.text, "mock detail");
 
@@ -118,8 +112,8 @@ describe("suspended thread display", () => {
         [idleThreadId]: idleEntry,
       });
 
-      // Test thread list
-      const listResult = await cmdThreadList(tmpDir, null, null, null, null, null);
+      // Test thread list — pass showAll=true to include suspended threads
+      const listResult = await cmdThreadList(tmpDir, null, null, null, null, null, true);
 
       // Find the suspended and idle threads in results
       const suspendedItem = listResult.find((item) => item.thread === suspendedThreadId);
@@ -169,13 +163,7 @@ describe("suspended thread display", () => {
             new: { role: "worker", prompt: "Start work", location: null },
             resume: { role: "worker", prompt: "Resume work", location: null },
           },
-          worker: {
-            needs_input: {
-              role: "$SUSPEND",
-              prompt: "Need clarification: {{{question}}}",
-              location: null,
-            },
-          },
+          worker: {},
         },
       });
 
@@ -186,9 +174,9 @@ describe("suspended thread display", () => {
       });
 
       const threadId = "01SUSPENDSHOW000000000" as ThreadId;
-      const outputHash = await uwf.store.cas.put(outputSchemaHash, {
-        $status: "needs_input",
-        question: "Which database to use?",
+      const outputHash = await uwf.store.cas.put(uwf.schemas.suspendOutput, {
+        $status: "$SUSPEND",
+        reason: "Need clarification: Which database to use?",
       });
       const detailHash = await uwf.store.cas.put(uwf.schemas.text, "mock detail");
 

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

@@ -1,6 +1,20 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 import type { CasRef, ThreadId, ThreadIndexEntry } from "@united-workforce/protocol";
 import { createThreadIndexEntry } from "@united-workforce/protocol";
-import { createUwfStore, setThread } from "../store.js";
+import { createUwfStore, setThread, type UwfStore } from "../store.js";
+
+/**
+ * Create an isolated UwfStore backed by a tmpdir.
+ * Sets process.env.OCAS_HOME so CAS resolves to the test's directory.
+ * Callers MUST save/restore OCAS_HOME in afterEach.
+ */
+export 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 ensureHeadInCas(
   uwf: Awaited<ReturnType<typeof createUwfStore>>,

package/src/__tests__/thread.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 { bootstrap, putSchema, type Store } from "@ocas/core";
@@ -11,8 +11,8 @@ import {
   THREAD_READ_DEFAULT_QUOTA,
 } from "../commands/thread.js";
 import type { UwfStore } from "../store.js";
-import { completeThread, createUwfStore, setThread } from "../store.js";
-import { seedThreads } from "./thread-test-helpers.js";
+import { completeThread, setThread } from "../store.js";
+import { makeUwfStore, seedThreads } from "./thread-test-helpers.js";
 
 // ── schemas used in tests ────────────────────────────────────────────────────
 
@@ -54,13 +54,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([
@@ -73,12 +66,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 });
 });
 
@@ -752,7 +752,7 @@ describe("cmdStepList with completed threads", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const result = await cmdStepList(tmpDir, threadId);
 
@@ -881,7 +881,7 @@ describe("cmdStepShow with completed threads", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const result = await cmdStepShow(tmpDir, stepHash);
 
@@ -944,7 +944,7 @@ describe("cmdThreadRead with completed threads", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
 
@@ -1007,7 +1007,7 @@ describe("cmdThreadRead with completed threads", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const markdown = await cmdThreadRead(
       tmpDir,