@united-workforce/cli 0.2.1-rc.9 → 0.4.0

package/src/__tests__/current-role.test.ts

@@ -4,7 +4,7 @@ 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 { cmdThreadList, cmdThreadShow, cmdThreadStart } from "../commands/thread.js";
 import { completeThread, createUwfStore, loadActiveThreads, setThread } from "../store.js";
 
@@ -307,10 +307,10 @@ describe("currentRole field", () => {
 
       const uwfForIndex = await createUwfStore(storageRoot);
       loadActiveThreads(uwfForIndex.varStore)[tid]!.head;
-      completeThread(uwfForIndex.varStore, tid, "completed");
+      completeThread(uwfForIndex.varStore, tid, "end");
 
       const result = await cmdThreadShow(storageRoot, tid);
-      expect(result.status).toBe("completed");
+      expect(result.status).toBe("end");
       expect(result.currentRole).toBe(null);
     } finally {
       await teardown();
@@ -352,6 +352,7 @@ describe("currentRole field", () => {
         workflow,
         pid: process.pid,
         startedAt: Date.now(),
+        processStartTime: getProcessStartTime(process.pid),
       });
 
       try {
@@ -378,13 +379,13 @@ describe("currentRole field", () => {
       const idleId = idle.thread as ThreadId;
 
       // completed thread
-      const comp = await cmdThreadStart(storageRoot, wf, "completed", tmpDir);
+      const comp = await cmdThreadStart(storageRoot, wf, "end", tmpDir);
       const compId = comp.thread as ThreadId;
       const uwfForIndex = await createUwfStore(storageRoot);
       const _compHead = loadActiveThreads(uwfForIndex.varStore)[compId]!.head;
-      completeThread(uwfForIndex.varStore, compId, "completed");
+      completeThread(uwfForIndex.varStore, compId, "end");
 
-      const list = await cmdThreadList(storageRoot, null, null, null, 0, 100);
+      const list = await cmdThreadList(storageRoot, null, null, null, 0, 100, true);
 
       const idleItem = list.find((i) => i.thread === idleId);
       expect(idleItem).toBeDefined();

package/src/__tests__/e2e-mock-agent.test.ts

@@ -78,9 +78,6 @@ afterEach(async () => {
 async function writeMockConfig(mockDataFixture: string): Promise<void> {
   const config = {
     defaultAgent: "mock",
-    defaultModel: "test",
-    providers: {},
-    models: {},
     agentOverrides: null,
     agents: {
       mock: {
@@ -187,7 +184,7 @@ function getStatus(store: Awaited<ReturnType<typeof openStore>>, outputRef: CasR
 
 // ── scenarios ─────────────────────────────────────────────────────────────────
 
-describe("E2E mock-agent: full uwf pipeline", () => {
+describe("E2E mock-agent: full uwf pipeline", { timeout: 15_000 }, () => {
   test("1. linear workflow runs planner then worker and reaches $END", async () => {
     await writeMockConfig("e2e-linear.mock.yaml");
     const workflowHash = await addWorkflow("e2e-linear.workflow.yaml", "test-linear");
@@ -209,7 +206,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     // Step 2 → worker → $END (thread archived to history).
     const step2 = execStep(threadId);
     expect(step2.done).toBe(true);
-    expect(step2.status).toBe("completed");
+    expect(step2.status).toBe("end");
     expect(step2.currentRole).toBeNull();
 
     // Verify CAS chain integrity: start → step1 → step2.
@@ -237,11 +234,11 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     const startNode = store.cas.get(startHash as CasRef);
     expect((startNode!.payload as StartNodePayload).workflow).toBe(workflowHash);
 
-    // Thread is completed: status changed to "completed", head updated.
+    // Thread is completed: status changed to "end", head updated.
     const uwf = await createUwfStore(uwfHome);
     const finalEntry = getThread(uwf.varStore, threadId);
     expect(finalEntry).not.toBeNull();
-    expect(finalEntry!.status).toBe("completed");
+    expect(finalEntry!.status).toBe("end");
     expect(finalEntry!.head).toBe(step2.head);
   });
 
@@ -270,7 +267,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
 
     const s4 = execStep(threadId);
     expect(s4.done).toBe(true);
-    expect(s4.status).toBe("completed");
+    expect(s4.status).toBe("end");
 
     // Verify the chain order and roles.
     const store = await openStore(casDir);
@@ -302,7 +299,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     const uwf = await createUwfStore(uwfHome);
     const finalEntry = getThread(uwf.varStore, threadId);
     expect(finalEntry).not.toBeNull();
-    expect(finalEntry!.status).toBe("completed");
+    expect(finalEntry!.status).toBe("end");
   });
 
   test("3. role mismatch in mock data makes the agent exit with an error", {
@@ -329,7 +326,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     const uwf = await createUwfStore(uwfHome);
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).not.toBeNull();
-    expect(entry!.status).not.toBe("completed");
+    expect(entry!.status).not.toBe("end");
     expect(entry!.head).toBe(step1.head);
   });
 
@@ -361,7 +358,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     const resume = runResume(threadId, "Here are the requirements");
     expect(resume.exitCode).toBe(0);
     const resumeOut = JSON.parse(resume.stdout.trim()) as StepOutputJson;
-    expect(resumeOut.status).toBe("completed");
+    expect(resumeOut.status).toBe("end");
     expect(resumeOut.done).toBe(true);
     expect(resumeOut.currentRole).toBeNull();
     expect(resumeOut.suspendedRole).toBeNull();
@@ -373,12 +370,12 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     expect(s1.role).toBe("planner");
     expect(s2.role).toBe("planner");
     expect(s2.prev).toBe(step1.head);
-    expect(getStatus(store, s1.output)).toBe("insufficient_info");
+    expect(getStatus(store, s1.output)).toBe("$SUSPEND");
     expect(getStatus(store, s2.output)).toBe("ready");
 
     const finalEntry = getThread((await createUwfStore(uwfHome)).varStore, threadId);
     expect(finalEntry).not.toBeNull();
-    expect(finalEntry!.status).toBe("completed");
+    expect(finalEntry!.status).toBe("end");
     expect(finalEntry!.head).toBe(resumeOut.head);
   });
 
@@ -404,7 +401,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     expect(results[0].currentRole).toBe("developer");
     expect(results[1].status).toBe("idle");
     expect(results[1].currentRole).toBe("reviewer");
-    expect(results[2].status).toBe("completed");
+    expect(results[2].status).toBe("end");
     expect(results[2].done).toBe(true);
 
     // Verify the CAS chain holds 3 step nodes in the correct order.
@@ -420,15 +417,15 @@ describe("E2E mock-agent: full uwf pipeline", () => {
 
     const finalEntry = getThread((await createUwfStore(uwfHome)).varStore, threadId);
     expect(finalEntry).not.toBeNull();
-    expect(finalEntry!.status).toBe("completed");
+    expect(finalEntry!.status).toBe("end");
     expect(finalEntry!.head).toBe(results[2].head);
   });
 
-  test("6. mustache edge prompt renders planner variables into the worker step", {
+  test("6. Liquid edge prompt renders planner variables into the worker step", {
     timeout: 30_000,
   }, async () => {
-    await writeMockConfig("e2e-mustache.mock.yaml");
-    const workflowHash = await addWorkflow("e2e-mustache.workflow.yaml", "test-mustache");
+    await writeMockConfig("e2e-liquid.mock.yaml");
+    const workflowHash = await addWorkflow("e2e-liquid.workflow.yaml", "test-liquid");
 
     const start = await cmdThreadStart(uwfHome, workflowHash, "Plan the task", uwfHome, tmpDir);
     const threadId = start.thread;
@@ -441,13 +438,13 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     // Step 2 → worker; the moderator renders the templated edge prompt before spawning it.
     const step2 = execStep(threadId);
     expect(step2.done).toBe(true);
-    expect(step2.status).toBe("completed");
+    expect(step2.status).toBe("end");
 
     const store = await openStore(casDir);
     const plannerStep = getStepNode(store, step1.head);
     expect(getStatus(store, plannerStep.output)).toBe("ready");
 
-    // The worker step's edgePrompt is the mustache-rendered template.
+    // The worker step's edgePrompt is the Liquid-rendered template.
     const workerStep = getStepNode(store, step2.head);
     expect(workerStep.role).toBe("worker");
     expect(workerStep.edgePrompt).toContain("fix/42-auth");
@@ -469,12 +466,12 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     // Step 1: planner outputs ready → $END → thread completed.
     const step1 = execStep(threadId);
     expect(step1.done).toBe(true);
-    expect(step1.status).toBe("completed");
+    expect(step1.status).toBe("end");
 
     const uwf1 = await createUwfStore(uwfHome);
     const entry1 = getThread(uwf1.varStore, threadId);
     expect(entry1).not.toBeNull();
-    expect(entry1!.status).toBe("completed");
+    expect(entry1!.status).toBe("end");
 
     // Resume the completed thread — should re-evaluate $START → planner.
     const resumeResult = runResume(threadId, "Additional context for round 2");
@@ -484,7 +481,7 @@ describe("E2E mock-agent: full uwf pipeline", () => {
     const uwf2 = await createUwfStore(uwfHome);
     const entry2 = getThread(uwf2.varStore, threadId);
     expect(entry2).not.toBeNull();
-    expect(entry2!.status).toBe("completed");
+    expect(entry2!.status).toBe("end");
     // Head should have advanced (not the same as step1).
     expect(entry2!.head).not.toBe(step1.head);
 

package/src/__tests__/fixtures/e2e-count.workflow.yaml

@@ -1,3 +1,4 @@
+version: 1
 name: test-count
 description: 3-step linear pipeline (analyst -> developer -> reviewer -> $END)
 roles:

package/src/__tests__/fixtures/e2e-linear.workflow.yaml

@@ -1,3 +1,4 @@
+version: 1
 name: test-linear
 description: Simple 2-step linear test (planner -> worker -> $END)
 roles:

package/src/__tests__/fixtures/{e2e-mustache.workflow.yaml → e2e-liquid.workflow.yaml}

@@ -1,4 +1,5 @@
-name: test-mustache
+version: 1
+name: test-liquid
 description: Planner emits template variables consumed by the worker edge prompt
 roles:
   planner:
@@ -30,6 +31,6 @@ graph:
     new: { role: planner, prompt: 'Plan the task' }
     resume: { role: planner, prompt: 'Review the previous run output and continue the work.' }
   planner:
-    ready: { role: worker, prompt: 'Work on branch {{{branch}}} in {{{repoPath}}}' }
+    ready: { role: worker, prompt: 'Work on branch {{ branch }} in {{ repoPath }}' }
   worker:
     done: { role: '$END', prompt: 'Complete' }

package/src/__tests__/fixtures/e2e-loop.workflow.yaml

@@ -1,3 +1,4 @@
+version: 1
 name: test-loop
 description: Branching test where the reviewer can reject and loop back to the developer
 roles:

package/src/__tests__/fixtures/e2e-suspend.mock.yaml

@@ -2,8 +2,8 @@ steps:
   - role: planner
     output: |
       ---
-      $status: insufficient_info
-      reason: missing requirements
+      $status: "$SUSPEND"
+      reason: 'Need more info: missing requirements'
       ---
       I need more information before I can plan this.
   - role: planner

package/src/__tests__/fixtures/e2e-suspend.workflow.yaml

@@ -1,3 +1,4 @@
+version: 1
 name: test-suspend
 description: Planner can suspend for more info or finish when ready
 roles:
@@ -6,20 +7,15 @@ roles:
     goal: Analyze the task
     capabilities: []
     procedure: Analyze the task and decide if more info is needed
-    output: Set $status to insufficient_info (with reason) or ready
+    output: Set $status to ready when done, or emit $status "$SUSPEND" (with reason) to pause for more info
     frontmatter:
-      oneOf:
-        - properties:
-            $status: { const: insufficient_info }
-            reason: { type: string }
-          required: [$status, reason]
-        - properties:
-            $status: { const: ready }
-          required: [$status]
+      type: object
+      required: [$status]
+      properties:
+        $status: { const: ready }
 graph:
   $START:
     new: { role: planner, prompt: 'Analyze the task' }
     resume: { role: planner, prompt: 'Review the previous run output and continue the work.' }
   planner:
-    insufficient_info: { role: '$SUSPEND', prompt: 'Need more info: {{{reason}}}' }
     ready: { role: '$END', prompt: 'Done' }

package/src/__tests__/issue-180-workflow-ref-removed.test.ts

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, test } from "vitest";
+
+const THREAD_TS_PATH = fileURLToPath(new URL("../commands/thread.ts", import.meta.url));
+
+describe("issue #180 — _workflowRef ghost parameter cleanup", () => {
+  test("thread.ts no longer references the dead _workflowRef parameter", async () => {
+    const source = await readFile(THREAD_TS_PATH, "utf8");
+    expect(source).not.toContain("_workflowRef");
+  });
+
+  test("resolveActiveThreadStatus is declared with exactly 4 parameters", async () => {
+    const source = await readFile(THREAD_TS_PATH, "utf8");
+    const declMatch = source.match(/async function resolveActiveThreadStatus\s*\(([\s\S]*?)\)\s*:/);
+    expect(declMatch).not.toBeNull();
+    const paramList = (declMatch as RegExpMatchArray)[1];
+    const params = paramList
+      .split(",")
+      .map((p) => p.trim())
+      .filter((p) => p.length > 0);
+    expect(params).toHaveLength(4);
+  });
+
+  test("every call site of resolveActiveThreadStatus passes exactly 4 args", async () => {
+    const source = await readFile(THREAD_TS_PATH, "utf8");
+    // Capture call-site arg lists. Excludes the function declaration: it's
+    // preceded by `function ` rather than parens-following-name.
+    const callRe = /(?<!function\s)resolveActiveThreadStatus\s*\(([^)]*)\)/g;
+    const callSites: string[] = [];
+    for (const match of source.matchAll(callRe)) {
+      callSites.push(match[1]);
+    }
+    expect(callSites.length).toBe(3);
+    for (const args of callSites) {
+      const argCount = args
+        .split(",")
+        .map((a) => a.trim())
+        .filter((a) => a.length > 0).length;
+      expect(argCount).toBe(4);
+    }
+  });
+});

package/src/__tests__/moderator-evaluate.test.ts

@@ -13,14 +13,14 @@ const solveIssueGraph: WorkflowPayload["graph"] = {
     },
   },
   planner: {
-    planned: { role: "developer", prompt: "Implement the plan: {{plan}}", location: null },
+    planned: { role: "developer", prompt: "Implement the plan: {{ plan }}", location: null },
   },
   developer: {
-    implemented: { role: "reviewer", prompt: "Review the changes: {{summary}}", location: null },
+    implemented: { role: "reviewer", prompt: "Review the changes: {{ summary }}", location: null },
   },
   reviewer: {
     approved: { role: "$END", prompt: "Done.", location: null },
-    rejected: { role: "developer", prompt: "Fix: {{comments}}", location: null },
+    rejected: { role: "developer", prompt: "Fix: {{ comments }}", location: null },
   },
 };
 
@@ -68,49 +68,6 @@ describe("evaluate", () => {
     });
   });
 
-  test("status-based routing (needs input → $SUSPEND)", () => {
-    const graph: Record<string, Record<string, Target>> = {
-      ...solveIssueGraph,
-      reviewer: {
-        ...solveIssueGraph.reviewer,
-        needs_input: { role: "$SUSPEND", prompt: "Waiting for user input.", location: null },
-      },
-    };
-    const result = evaluate(graph, "reviewer", { $status: "needs_input" });
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        action: "suspend",
-        suspendedRole: "reviewer",
-        prompt: "Waiting for user input.",
-      },
-    });
-  });
-
-  test("$SUSPEND prompt template renders mustache variables", () => {
-    const graph: Record<string, Record<string, Target>> = {
-      reviewer: {
-        needs_input: {
-          role: "$SUSPEND",
-          prompt: "Please clarify: {{{question}}}",
-          location: null,
-        },
-      },
-    };
-    const result = evaluate(graph, "reviewer", {
-      $status: "needs_input",
-      question: "Which API endpoint?",
-    });
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        action: "suspend",
-        suspendedRole: "reviewer",
-        prompt: "Please clarify: Which API endpoint?",
-      },
-    });
-  });
-
   test("missing role in graph → error", () => {
     const result = evaluate(solveIssueGraph, "unknown-role", { $status: "new" });
     expect(result.ok).toBe(false);
@@ -127,7 +84,7 @@ describe("evaluate", () => {
     }
   });
 
-  test("mustache template rendering with simple fields", () => {
+  test("liquid template rendering with simple fields", () => {
     const result = evaluate(solveIssueGraph, "planner", {
       $status: "planned",
       plan: "Add auth middleware",
@@ -142,7 +99,7 @@ describe("evaluate", () => {
     });
   });
 
-  test("mustache does not HTML-escape prompt content", () => {
+  test("liquid does not HTML-escape prompt content", () => {
     const result = evaluate(solveIssueGraph, "reviewer", {
       $status: "rejected",
       comments: 'use <T> & "Result<T, E>" types',
@@ -153,10 +110,10 @@ describe("evaluate", () => {
     });
   });
 
-  test("triple mustache also works for unescaped output", () => {
+  test("liquid renders HTML content without escaping", () => {
     const graph: Record<string, Record<string, Target>> = {
       reviewer: {
-        rejected: { role: "developer", prompt: "Fix: {{{comments}}}", location: null },
+        rejected: { role: "developer", prompt: "Fix: {{ comments }}", location: null },
       },
     };
     const result = evaluate(graph, "reviewer", {
@@ -181,12 +138,12 @@ describe("evaluate", () => {
     }
   });
 
-  test("mustache template with nested object paths", () => {
+  test("liquid template with nested object paths", () => {
     const graph: Record<string, Record<string, Target>> = {
       reviewer: {
         rejected: {
           role: "developer",
-          prompt: "Address: {{review.comments}}",
+          prompt: "Address: {{ review.comments }}",
           location: null,
         },
       },