@united-workforce/cli 0.3.0 → 0.5.0

package/src/__tests__/validate-semantic.test.ts

@@ -5,6 +5,7 @@ import { validateWorkflow } from "../validate-semantic.js";
 /** Build a valid two-role workflow that passes all checks. */
 function makeWorkflow(overrides?: Partial<WorkflowPayload>): WorkflowPayload {
   const base: WorkflowPayload = {
+    version: 1,
     name: "test-workflow",
     description: "A test workflow",
     roles: {
@@ -55,10 +56,10 @@ function makeWorkflow(overrides?: Partial<WorkflowPayload>): WorkflowPayload {
         new: { role: "writer", prompt: "Begin writing", location: null },
         resume: { role: "writer", prompt: "Review previous output and continue", location: null },
       },
-      writer: { done: { role: "reviewer", prompt: "Review this: {{{plan}}}", location: null } },
+      writer: { done: { role: "reviewer", prompt: "Review this: {{ plan }}", location: null } },
       reviewer: {
-        approved: { role: "$END", prompt: "Done: {{{summary}}}", location: null },
-        rejected: { role: "writer", prompt: "Fix: {{{reason}}}", location: null },
+        approved: { role: "$END", prompt: "Done: {{ summary }}", location: null },
+        rejected: { role: "writer", prompt: "Fix: {{ reason }}", location: null },
       },
     },
   };
@@ -208,8 +209,6 @@ describe("Suite 2: Graph Structure", () => {
 
 describe("Suite 3: Status-Edge Consistency", () => {
   test("3.1 user role using _ graph key is treated as an unknown status", () => {
-    // "_" is no longer special-cased — it's just a status key that does not
-    // match the role's $status enum, so it surfaces as extra/missing keys.
     const wf = makeWorkflow();
     wf.graph.writer = { _: { role: "reviewer", prompt: "Review", location: null } };
     const errors = validateWorkflow(wf);
@@ -288,7 +287,7 @@ describe("Suite 3b: Enum-Based $status is Rejected", () => {
     };
     wf.graph.reviewer = {
       approved: { role: "$END", prompt: "Done", location: null },
-      rejected: { role: "writer", prompt: "Fix: {{{comments}}}", location: null },
+      rejected: { role: "writer", prompt: "Fix: {{ comments }}", location: null },
     };
     const errors = validateWorkflow(wf);
     expect(errors.some((e) => e.includes("must define") && e.includes("const"))).toBe(true);
@@ -307,7 +306,9 @@ describe("Suite 3b: Enum-Based $status is Rejected", () => {
         required: ["$status", "plan"],
       } as unknown as string,
     };
-    wf.graph.writer = { ready: { role: "reviewer", prompt: "Review: {{{plan}}}", location: null } };
+    wf.graph.writer = {
+      ready: { role: "reviewer", prompt: "Review: {{ plan }}", location: null },
+    };
     const errors = validateWorkflow(wf);
     expect(errors.some((e) => e.includes("must define") && e.includes("const"))).toBe(true);
   });
@@ -352,7 +353,7 @@ describe("Suite 3c: Const-Based Flat Schema", () => {
     expect(errors.some((e) => e.includes("extra status keys") && e.includes("extra"))).toBe(true);
   });
 
-  test("3c.3 flat schema with const $status validates mustache vars", () => {
+  test("3c.3 flat schema with const $status validates template vars", () => {
     const wf = makeWorkflow();
     wf.roles.writer = {
       ...wf.roles.writer,
@@ -366,56 +367,48 @@ describe("Suite 3c: Const-Based Flat Schema", () => {
       } as unknown as string,
     };
     wf.graph.writer = {
-      done: { role: "reviewer", prompt: "Review: {{{nonexistent}}}", location: null },
+      done: { role: "reviewer", prompt: "Review: {{ nonexistent }}", location: null },
     };
     const errors = validateWorkflow(wf);
-    expect(
-      errors.some(
-        (e) => e.includes('prompt variable "nonexistent"') && e.includes('role "writer"'),
-      ),
-    ).toBe(true);
+    expect(errors.some((e) => e.includes("nonexistent") && e.includes('role "writer"'))).toBe(true);
   });
 });
 
-describe("Suite 4: Mustache Template Variable Existence", () => {
-  test("4.1 prompt references nonexistent variable (enum status)", () => {
+describe("Suite 4: Template Variable Existence (LiquidJS strict-render)", () => {
+  test("4.1 prompt references nonexistent variable (flat schema)", () => {
     const wf = makeWorkflow();
     wf.graph.writer = {
-      done: { role: "reviewer", prompt: "Review: {{{branch}}}", location: null },
+      done: { role: "reviewer", prompt: "Review: {{ branch }}", location: null },
     };
     const errors = validateWorkflow(wf);
-    expect(
-      errors.some(
-        (e) => e.includes('prompt variable "branch"') && e.includes('role "writer" frontmatter'),
-      ),
-    ).toBe(true);
+    expect(errors.some((e) => e.includes("branch") && e.includes('role "writer"'))).toBe(true);
   });
 
   test("4.2 prompt references nonexistent variable (multi-exit)", () => {
     const wf = makeWorkflow();
     wf.graph.reviewer = {
-      approved: { role: "$END", prompt: "Done: {{{branch}}}", location: null },
-      rejected: { role: "writer", prompt: "Fix: {{{reason}}}", location: null },
+      approved: { role: "$END", prompt: "Done: {{ branch }}", location: null },
+      rejected: { role: "writer", prompt: "Fix: {{ reason }}", location: null },
     };
     const errors = validateWorkflow(wf);
     expect(
-      errors.some((e) =>
-        e.includes('prompt variable "branch" not found in role "reviewer" variant "approved"'),
-      ),
+      errors.some((e) => e.includes("branch") && e.includes("reviewer") && e.includes("approved")),
     ).toBe(true);
   });
 
-  test("4.3 valid mustache variables pass", () => {
+  test("4.3 valid template variables pass", () => {
     const wf = makeWorkflow();
     const errors = validateWorkflow(wf);
     expect(errors).toEqual([]);
   });
 
-  test("4.4 $status variable is always valid", () => {
+  test("4.4 $status in template is rejected ($ prefix invalid in LiquidJS)", () => {
     const wf = makeWorkflow();
-    wf.graph.writer = { done: { role: "reviewer", prompt: "Status: {{$status}}", location: null } };
+    wf.graph.writer = {
+      done: { role: "reviewer", prompt: "Status: {{ $status }}", location: null },
+    };
     const errors = validateWorkflow(wf);
-    expect(errors).toEqual([]);
+    expect(errors.length).toBeGreaterThan(0);
   });
 });
 
@@ -469,6 +462,41 @@ describe("Suite 5: oneOf Discriminant Validity", () => {
   });
 });
 
+describe("Suite 7: $SUSPEND is no longer a valid graph target", () => {
+  test("7.1 edge targeting $SUSPEND is rejected with a migration hint", () => {
+    const wf = makeWorkflow();
+    wf.graph.writer = {
+      done: { role: "$SUSPEND", prompt: "Need more info", location: null },
+    };
+    const errors = validateWorkflow(wf);
+    expect(
+      errors.some(
+        (e) =>
+          e.includes("$SUSPEND") &&
+          e.includes("no longer a valid graph target") &&
+          e.includes('Emit $status: "$SUSPEND"'),
+      ),
+    ).toBe(true);
+  });
+
+  test("7.2 $SUSPEND as a graph node is rejected", () => {
+    const wf = makeWorkflow();
+    (wf.graph as Record<string, unknown>).$SUSPEND = {
+      done: { role: "$END", prompt: "done", location: null },
+    };
+    const errors = validateWorkflow(wf);
+    expect(
+      errors.some((e) => e.includes("$SUSPEND") && e.includes("no longer a valid graph node")),
+    ).toBe(true);
+  });
+
+  test("7.3 a role emitting $SUSPEND from its output (not the graph) passes", () => {
+    const wf = makeWorkflow();
+    const errors = validateWorkflow(wf);
+    expect(errors.some((e) => e.includes("$SUSPEND"))).toBe(false);
+  });
+});
+
 describe("Suite 6: Multiple Errors Collection", () => {
   test("6.1 multiple errors collected", () => {
     const wf = makeWorkflow();
@@ -487,9 +515,66 @@ describe("Suite 6: Multiple Errors Collection", () => {
     };
     // unknown graph reference
     wf.graph.nonexistent = { done: { role: "$END", prompt: "done", location: null } };
-    // bad mustache var
-    wf.graph.writer = { done: { role: "reviewer", prompt: "{{{badvar}}}", location: null } };
+    // bad template var
+    wf.graph.writer = { done: { role: "reviewer", prompt: "{{ badvar }}", location: null } };
     const errors = validateWorkflow(wf);
     expect(errors.length).toBeGreaterThanOrEqual(3);
   });
 });
+
+describe("Suite 7: Reserved Frontmatter Properties", () => {
+  test("7.1 flat schema with _body property is rejected", () => {
+    const wf = makeWorkflow();
+    wf.roles.writer = {
+      ...wf.roles.writer,
+      frontmatter: {
+        type: "object",
+        properties: {
+          $status: { const: "done" },
+          _body: { type: "string" },
+        },
+        required: ["$status"],
+      } as unknown as string,
+    };
+    wf.graph.writer = { done: { role: "reviewer", prompt: "ok", location: null } };
+    const errors = validateWorkflow(wf);
+    expect(errors.some((e) => e.includes("_body") && e.includes("reserved"))).toBe(true);
+  });
+
+  test("7.2 oneOf schema with _body in a variant is rejected", () => {
+    const wf = makeWorkflow();
+    wf.roles.writer = {
+      ...wf.roles.writer,
+      frontmatter: {
+        oneOf: [
+          {
+            properties: {
+              $status: { const: "done" },
+              _body: { type: "string" },
+            },
+            required: ["$status"],
+          },
+          {
+            properties: {
+              $status: { const: "failed" },
+              reason: { type: "string" },
+            },
+            required: ["$status", "reason"],
+          },
+        ],
+      } as unknown as string,
+    };
+    wf.graph.writer = {
+      done: { role: "reviewer", prompt: "ok", location: null },
+      failed: { role: "$END", prompt: "failed", location: null },
+    };
+    const errors = validateWorkflow(wf);
+    expect(errors.some((e) => e.includes("_body") && e.includes("reserved"))).toBe(true);
+  });
+
+  test("7.3 schema without _body passes", () => {
+    const wf = makeWorkflow();
+    const errors = validateWorkflow(wf);
+    expect(errors.some((e) => e.includes("_body"))).toBe(false);
+  });
+});

package/src/__tests__/workflow-list-recursive.test.ts

@@ -0,0 +1,370 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CasRef, WorkflowPayload } from "@united-workforce/protocol";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { stringify } from "yaml";
+import { cmdThreadStart } from "../commands/thread.js";
+import { cmdWorkflowList } from "../commands/workflow.js";
+import { discoverProjectWorkflows } from "../store.js";
+import { makeUwfStore } from "./thread-test-helpers.js";
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function makeMinimalPayload(name: string, description: string): WorkflowPayload {
+  return {
+    version: 1,
+    name,
+    description,
+    roles: {
+      worker: {
+        description: "worker role",
+        goal: "do work",
+        capabilities: [],
+        procedure: "",
+        output: "",
+        frontmatter: {
+          type: "object",
+          properties: {
+            $status: { const: "done" },
+          },
+          required: ["$status"],
+        } as unknown as CasRef,
+      },
+    },
+    graph: {
+      $START: {
+        new: { role: "worker", prompt: "start working", location: null },
+        resume: { role: "worker", prompt: "resume working", location: null },
+      },
+      worker: { done: { role: "$END", prompt: "done", location: null } },
+    },
+  };
+}
+
+async function createWorkflowYaml(name: string, version: string | null = null): Promise<string> {
+  const payload = makeMinimalPayload(
+    name,
+    version !== null ? `Test workflow (${version})` : "Test workflow",
+  );
+  return stringify(payload);
+}
+
+// ── fixture ───────────────────────────────────────────────────────────────────
+
+let tmpDir: string;
+let storageRoot: string;
+let projectRoot: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-wf-list-recursive-"));
+  storageRoot = join(tmpDir, "storage");
+  projectRoot = join(tmpDir, "project");
+  await mkdir(storageRoot, { recursive: true });
+  await mkdir(projectRoot, { recursive: true });
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+// ── discoverProjectWorkflows — parent traversal ───────────────────────────────
+
+describe("discoverProjectWorkflows — parent traversal", () => {
+  test("T1: finds workflows in cwd's .workflows/", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    expect(entries.map((e) => e.name)).toContain("solve-issue");
+  });
+
+  test("T2: finds workflows in ancestor's .workflows/ when called from subdirectory", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "packages", "cli", "src");
+    await mkdir(subdir, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(subdir);
+
+    expect(entries.map((e) => e.name)).toContain("solve-issue");
+  });
+
+  test("T3: returns [] when no .workflows/ or .workflow/ exists in any ancestor", async () => {
+    // Use a deep path under tmpDir that has no .workflows/ or .workflow/ on the way up.
+    // (Traversal will stop at filesystem root and find nothing.)
+    const deepPath = join(tmpDir, "isolated", "no", "workflow", "here");
+    await mkdir(deepPath, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(deepPath);
+
+    expect(entries).toEqual([]);
+  });
+
+  test("T4: .workflows/ entries win over .workflow/ within the same directory", async () => {
+    const primaryDir = join(projectRoot, ".workflows");
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(primaryDir, { recursive: true });
+    await mkdir(legacyDir, { recursive: true });
+
+    await writeFile(
+      join(primaryDir, "solve-issue.yaml"),
+      await createWorkflowYaml("solve-issue", "new"),
+    );
+    await writeFile(
+      join(legacyDir, "solve-issue.yaml"),
+      await createWorkflowYaml("solve-issue", "legacy"),
+    );
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(primaryDir, "solve-issue.yaml"));
+  });
+
+  test("T5: nearest .workflows/ wins over ancestor's .workflows/", async () => {
+    const ancestorWf = join(projectRoot, ".workflows");
+    await mkdir(ancestorWf, { recursive: true });
+    await writeFile(join(ancestorWf, "foo.yaml"), await createWorkflowYaml("foo", "ancestor"));
+
+    const nearDir = join(projectRoot, "pkg");
+    const nearWf = join(nearDir, ".workflows");
+    await mkdir(nearWf, { recursive: true });
+    await writeFile(join(nearWf, "foo.yaml"), await createWorkflowYaml("foo", "near"));
+
+    const entries = await discoverProjectWorkflows(nearDir);
+
+    const match = entries.find((e) => e.name === "foo");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(nearWf, "foo.yaml"));
+    // Should not include duplicates from ancestor
+    expect(entries.filter((e) => e.name === "foo")).toHaveLength(1);
+  });
+
+  test("T6: returns all entries from the nearest .workflows/ when called from a deep subdir", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+    await writeFile(join(wfDir, "review-code.yaml"), await createWorkflowYaml("review-code"));
+
+    const deep = join(projectRoot, "a", "b", "c", "d");
+    await mkdir(deep, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(deep);
+
+    const names = entries.map((e) => e.name).sort();
+    expect(names).toEqual(["review-code", "solve-issue"]);
+  });
+
+  test("T7: discovers folder-based layout (name/index.yaml) via parent traversal under .workflows/", async () => {
+    const folderDir = join(projectRoot, ".workflows", "solve-issue");
+    await mkdir(folderDir, { recursive: true });
+    await writeFile(join(folderDir, "index.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "deep", "sub");
+    await mkdir(subdir, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(subdir);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(folderDir, "index.yaml"));
+  });
+
+  test("T8: .workflow/ (legacy) is still discovered when .workflows/ does not exist", async () => {
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(legacyDir, { recursive: true });
+    await writeFile(join(legacyDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(legacyDir, "solve-issue.yaml"));
+  });
+
+  test("T9: nearest directory with EITHER variant stops traversal", async () => {
+    // Setup: ancestor .workflows/ + near .workflow/ only — near wins, ancestor not merged.
+    const ancestorWf = join(tmpDir, ".workflows");
+    await mkdir(ancestorWf, { recursive: true });
+    await writeFile(join(ancestorWf, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const nearLegacyDir = join(projectRoot, ".workflow");
+    await mkdir(nearLegacyDir, { recursive: true });
+    await writeFile(join(nearLegacyDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+    const names = entries.map((e) => e.name);
+    expect(names).toContain("local");
+    expect(names).not.toContain("leak");
+  });
+});
+
+// ── discoverProjectWorkflows — .git boundary ─────────────────────────────────
+
+describe("discoverProjectWorkflows — .git boundary", () => {
+  test("G1: .git directory stops traversal", async () => {
+    // Setup: tmpDir/repo/.git/ (dir), tmpDir/.workflows/leak.yaml, start from tmpDir/repo/sub/deep/
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    // Workflow above repo root — should NOT be reachable
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub", "deep");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries).toEqual([]);
+  });
+
+  test("G2: .git file (worktree) stops traversal", async () => {
+    // Setup: tmpDir/repo/.git as a FILE, tmpDir/.workflows/leak.yaml, start from tmpDir/repo/pkg/
+    const repoDir = join(tmpDir, "repo");
+    await mkdir(repoDir, { recursive: true });
+    await writeFile(join(repoDir, ".git"), "gitdir: /some/other/path/.git/worktrees/repo");
+
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "pkg");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries).toEqual([]);
+  });
+
+  test("G3: workflow at .git boundary IS found (primary .workflows/)", async () => {
+    // Setup: tmpDir/repo/.git/ (dir), tmpDir/repo/.workflows/local.yaml, start from tmpDir/repo/sub/
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const wfDir = join(repoDir, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries.map((e) => e.name)).toContain("local");
+  });
+
+  test("G4: workflow below .git is found, above is not", async () => {
+    // Setup: tmpDir/repo/.git/ + tmpDir/repo/.workflows/local.yaml + tmpDir/.workflows/leak.yaml
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const localWfDir = join(repoDir, ".workflows");
+    await mkdir(localWfDir, { recursive: true });
+    await writeFile(join(localWfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries.map((e) => e.name)).toEqual(["local"]);
+  });
+});
+
+// ── findWorkflowInParents (via cmdThreadStart) — .git boundary ───────────────
+
+describe("findWorkflowInParents via cmdThreadStart — .git boundary", () => {
+  test("G5: .git stops traversal — workflow above boundary is not found", async () => {
+    await makeUwfStore(storageRoot);
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    // Workflow above .git boundary
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    // cmdThreadStart should fail — "leak" is above the .git boundary
+    await expect(cmdThreadStart(storageRoot, "leak", "prompt", startFrom)).rejects.toThrow();
+  });
+
+  test("G6: workflow at .git boundary IS found via cmdThreadStart", async () => {
+    await makeUwfStore(storageRoot);
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const wfDir = join(repoDir, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const result = await cmdThreadStart(storageRoot, "local", "prompt", startFrom);
+    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+  });
+});
+
+// ── cmdWorkflowList — parent traversal ───────────────────────────────────────
+
+describe("cmdWorkflowList — parent traversal", () => {
+  test("B9: lists local workflows discovered from a subdirectory", async () => {
+    await makeUwfStore(storageRoot);
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "packages", "foo", "src");
+    await mkdir(subdir, { recursive: true });
+
+    const result = await cmdWorkflowList(storageRoot, subdir);
+
+    const match = result.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.hash).toBe("(local)");
+    expect(match?.origin).toBe("local");
+  });
+
+  test("aligns with cmdThreadStart discovery from same subdirectory", async () => {
+    await makeUwfStore(storageRoot);
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "foo.yaml"), await createWorkflowYaml("foo"));
+
+    const subdir = join(projectRoot, "packages", "foo", "src");
+    await mkdir(subdir, { recursive: true });
+
+    // cmdThreadStart already resolves foo successfully from subdir (existing behavior)
+    const startResult = await cmdThreadStart(storageRoot, "foo", "prompt", subdir);
+    expect(startResult.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+
+    // cmdWorkflowList must ALSO include foo (newly aligned behavior)
+    const listResult = await cmdWorkflowList(storageRoot, subdir);
+    const match = listResult.find((e) => e.name === "foo");
+    expect(match).toBeDefined();
+    expect(match?.origin).toBe("local");
+  });
+});