@united-workforce/cli 0.6.1 → 0.7.0

package/src/__tests__/broker-prompt.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Unit tests for `assembleBrokerPrompt` (#387).
+ *
+ * Verifies the broker path assembles the same five-part prompt the legacy
+ * spawned-agent path produced: output-format instruction, thread progress,
+ * role prompt (goal/procedure/output), task prompt, and the
+ * continuation/edge-prompt context (branching on first visit vs re-entry).
+ */
+
+import type { CasRef, StepContext, ThreadId, WorkflowPayload } from "@united-workforce/protocol";
+import { describe, expect, test } from "vitest";
+import { assembleBrokerPrompt } from "../commands/broker-step.js";
+
+const THREAD_ID = "06FCBROKERPROMPTTEST000001" as ThreadId;
+
+const OUTPUT_FORMAT_INSTRUCTION = "## Deliverable Format\n\nemit YAML frontmatter";
+
+function buildWorkflow(): WorkflowPayload {
+  return {
+    version: 1,
+    name: "review-flow",
+    description: "two-role review flow",
+    roles: {
+      developer: {
+        description: "writes code",
+        goal: "implement the requested behavior",
+        capabilities: ["coding"],
+        procedure: "follow the spec and write tests",
+        output: "a patch plus a short summary",
+        frontmatter: "schema_developer" as CasRef,
+      },
+      reviewer: {
+        description: "reviews code",
+        goal: "review the implementation",
+        capabilities: [],
+        procedure: "check the diff carefully",
+        output: "approve or reject",
+        frontmatter: "schema_reviewer" as CasRef,
+      },
+    },
+    graph: {},
+  };
+}
+
+function stepContext(role: string, content: string | null, output: unknown): StepContext {
+  return {
+    role,
+    output,
+    detail: "detail_ref" as CasRef,
+    agent: "test-agent",
+    edgePrompt: "",
+    startedAtMs: 0,
+    completedAtMs: 1,
+    cwd: "",
+    assembledPrompt: null,
+    usage: null,
+    previousAttempts: null,
+    content,
+  };
+}
+
+describe("assembleBrokerPrompt", () => {
+  test("first visit with no prior steps embeds role prompt, task, and edge prompt", () => {
+    const prompt = assembleBrokerPrompt({
+      workflow: buildWorkflow(),
+      role: "developer",
+      threadId: THREAD_ID,
+      startPrompt: "Build the login form",
+      steps: [],
+      edgePrompt: "Implement the behavior defined in the spec files",
+      outputFormatInstruction: OUTPUT_FORMAT_INSTRUCTION,
+    });
+
+    // 1. output-format instruction
+    expect(prompt).toContain("## Deliverable Format");
+    // 2. thread progress
+    expect(prompt).toContain("## Thread Progress");
+    expect(prompt).toContain("This is the first step of the thread");
+    // 3. role prompt (goal + procedure + output)
+    expect(prompt).toContain("## Goal");
+    expect(prompt).toContain("implement the requested behavior");
+    expect(prompt).toContain("## Procedure");
+    expect(prompt).toContain("follow the spec and write tests");
+    expect(prompt).toContain("## Output");
+    expect(prompt).toContain("a patch plus a short summary");
+    // 4. task prompt
+    expect(prompt).toContain("## Task");
+    expect(prompt).toContain("Build the login form");
+    // 5. edge prompt (no prior steps → "Current Instruction")
+    expect(prompt).toContain("## Current Instruction");
+    expect(prompt).toContain("Implement the behavior defined in the spec files");
+  });
+
+  test("first visit with prior steps includes step content as continuation context", () => {
+    const steps: StepContext[] = [
+      stepContext("planner", "Here is the detailed plan for the feature.", { $status: "done" }),
+    ];
+
+    const prompt = assembleBrokerPrompt({
+      workflow: buildWorkflow(),
+      role: "developer",
+      threadId: THREAD_ID,
+      startPrompt: "Build the login form",
+      steps,
+      edgePrompt: "Implement the plan",
+      outputFormatInstruction: OUTPUT_FORMAT_INSTRUCTION,
+    });
+
+    // Developer has not spoken yet → first visit, prior steps shown WITH content.
+    expect(prompt).toContain("## What Happened Since Your Last Turn");
+    expect(prompt).toContain("Here is the detailed plan for the feature.");
+    expect(prompt).toContain("## Moderator Instruction");
+    expect(prompt).toContain("Implement the plan");
+    // Thread progress reflects the prior step.
+    expect(prompt).toContain("Thread step 2");
+  });
+
+  test("re-entry shows only steps since last visit (meta-only continuation)", () => {
+    const steps: StepContext[] = [
+      stepContext("developer", "My first implementation attempt.", { $status: "done" }),
+      stepContext("reviewer", "Please fix the validation logic.", { $status: "reject" }),
+    ];
+
+    const prompt = assembleBrokerPrompt({
+      workflow: buildWorkflow(),
+      role: "developer",
+      threadId: THREAD_ID,
+      startPrompt: "Build the login form",
+      steps,
+      edgePrompt: "Address the reviewer feedback",
+      outputFormatInstruction: OUTPUT_FORMAT_INSTRUCTION,
+    });
+
+    // Re-entry: continuation lists the reviewer step since the last developer turn.
+    expect(prompt).toContain("## What Happened Since Your Last Turn");
+    expect(prompt).toContain("reviewer");
+    expect(prompt).toContain("## Moderator Instruction");
+    expect(prompt).toContain("Address the reviewer feedback");
+    // Meta-only re-entry omits raw step content from before the last visit.
+    expect(prompt).not.toContain("My first implementation attempt.");
+  });
+});

package/src/__tests__/config.test.ts

@@ -21,18 +21,15 @@ describe("config command", () => {
     return configPath;
   }
 
-  // Sample test config — engine-only (no providers/models/defaultModel/modelOverrides)
+  // Sample test config — engine-only (no providers/models/defaultModel/modelOverrides).
+  // Phase 3 (#380) replaced the legacy {command, args} agent shape with {host, gateway}.
   const sampleConfig = `agents:
   hermes:
-    command: uwf-hermes
-    args:
-      - --provider
-      - dashscope
+    host: http://127.0.0.1:7900
+    gateway: hermes
   claude-code:
-    command: claude-code
-    args:
-      - --profile
-      - work
+    host: http://127.0.0.1:7901
+    gateway: claude-code
 defaultAgent: hermes
 `;
 
@@ -41,7 +38,7 @@ defaultAgent: hermes
       test("splits dot notation correctly", () => {
         expect(parseDotPath("a.b.c")).toEqual(["a", "b", "c"]);
         expect(parseDotPath("defaultAgent")).toEqual(["defaultAgent"]);
-        expect(parseDotPath("agents.hermes.command")).toEqual(["agents", "hermes", "command"]);
+        expect(parseDotPath("agents.hermes.host")).toEqual(["agents", "hermes", "host"]);
       });
     });
 
@@ -85,7 +82,7 @@ defaultAgent: hermes
     describe("maskApiKeys", () => {
       test("returns deep clone (no mutation) — engine config has no apiKey to mask", () => {
         const config = {
-          agents: { hermes: { command: "uwf-hermes", args: [] } },
+          agents: { hermes: { host: "http://127.0.0.1:7900", gateway: "hermes" } },
           defaultAgent: "hermes",
         };
         const masked = maskApiKeys(config);
@@ -153,12 +150,12 @@ defaultAgent: hermes
       }
     });
 
-    test("retrieves array value (agents.hermes.args)", async () => {
+    test("retrieves nested string value (agents.hermes.host)", async () => {
       const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
       try {
         createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(result).toEqual(["--provider", "dashscope"]);
+        const result = await cmdConfigGet(tempDir, "agents.hermes.host");
+        expect(result).toBe("http://127.0.0.1:7900");
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }
@@ -208,18 +205,17 @@ defaultAgent: hermes
       }
     });
 
-    test("sets array value for args key with valid JSON array", async () => {
+    test("sets nested string value (agents.hermes.host)", async () => {
       const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
       try {
         createTestConfig(tempDir, sampleConfig);
-        const newArgs = '["--new", "--flags"]';
-        const result = await cmdConfigSet(tempDir, "agents.hermes.args", newArgs);
+        const result = await cmdConfigSet(tempDir, "agents.hermes.host", "http://10.0.0.1:7900");
         expect(result).toEqual({
-          key: "agents.hermes.args",
-          value: ["--new", "--flags"],
+          key: "agents.hermes.host",
+          value: "http://10.0.0.1:7900",
         });
-        const updated = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(updated).toEqual(["--new", "--flags"]);
+        const updated = await cmdConfigGet(tempDir, "agents.hermes.host");
+        expect(updated).toBe("http://10.0.0.1:7900");
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }
@@ -230,8 +226,8 @@ defaultAgent: hermes
       try {
         createTestConfig(tempDir, sampleConfig);
         await cmdConfigSet(tempDir, "defaultAgent", "claude-code");
-        const cmd = await cmdConfigGet(tempDir, "agents.hermes.command");
-        expect(cmd).toBe("uwf-hermes");
+        const host = await cmdConfigGet(tempDir, "agents.hermes.host");
+        expect(host).toBe("http://127.0.0.1:7900");
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }
@@ -260,29 +256,29 @@ defaultAgent: hermes
       }
     });
 
-    test("throws error when array value is invalid JSON for args key", async () => {
+    test("throws error when value for unknown nested field is invalid", async () => {
       const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
       try {
         createTestConfig(tempDir, sampleConfig);
-        await expect(
-          cmdConfigSet(tempDir, "agents.hermes.args", "[invalid json"),
-        ).rejects.toThrow();
+        await expect(cmdConfigSet(tempDir, "agents.hermes.args", "[invalid json")).rejects.toThrow(
+          /Unknown field/,
+        );
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }
     });
 
-    test("sets agent command (agents.claude-code.command)", async () => {
+    test("sets agent gateway (agents.claude-code.gateway)", async () => {
       const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
       try {
         createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigSet(tempDir, "agents.claude-code.command", "new-command");
+        const result = await cmdConfigSet(tempDir, "agents.claude-code.gateway", "new-gateway");
         expect(result).toEqual({
-          key: "agents.claude-code.command",
-          value: "new-command",
+          key: "agents.claude-code.gateway",
+          value: "new-gateway",
         });
-        const updated = await cmdConfigGet(tempDir, "agents.claude-code.command");
-        expect(updated).toBe("new-command");
+        const updated = await cmdConfigGet(tempDir, "agents.claude-code.gateway");
+        expect(updated).toBe("new-gateway");
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }
@@ -392,12 +388,12 @@ defaultAgent: hermes
       const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
       try {
         createTestConfig(tempDir, sampleConfig);
-        await cmdConfigSet(tempDir, "agents.hermes.command", "uwf-hermes");
-        await cmdConfigSet(tempDir, "agents.hermes.args", '["--flag"]');
-        const command = await cmdConfigGet(tempDir, "agents.hermes.command");
-        const args = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(command).toBe("uwf-hermes");
-        expect(args).toEqual(["--flag"]);
+        await cmdConfigSet(tempDir, "agents.hermes.host", "http://example:7900");
+        await cmdConfigSet(tempDir, "agents.hermes.gateway", "hermes-gw");
+        const host = await cmdConfigGet(tempDir, "agents.hermes.host");
+        const gateway = await cmdConfigGet(tempDir, "agents.hermes.gateway");
+        expect(host).toBe("http://example:7900");
+        expect(gateway).toBe("hermes-gw");
       } finally {
         rmSync(tempDir, { recursive: true, force: true });
       }

package/src/__tests__/e2e-broker-step.test.ts

@@ -0,0 +1,320 @@
+/**
+ * Phase 3 (#380) — direct e2e test for `executeBrokerStep`.
+ *
+ * Stubs `globalThis.fetch` so the Sumeru `createSession` POST and
+ * `sendMessage` SSE POST come back deterministically. Verifies:
+ *   1. broker.send() is invoked with the resolved (host, gateway, cwd) route.
+ *   2. The agent's last assistant turn is extracted via the frontmatter fast-path.
+ *   3. A StepNode is persisted to CAS with the role's output schema, edge prompt,
+ *      and accumulated usage, satisfying schema validation.
+ *   4. The broker session store rows the (threadId, role) → sessionId mapping.
+ */
+
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { putSchema } from "@ocas/core";
+import type {
+  CasRef,
+  StepNodePayload,
+  ThreadId,
+  WorkflowConfig,
+  WorkflowPayload,
+} from "@united-workforce/protocol";
+import { createProcessLogger } from "@united-workforce/util";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { executeBrokerStep, openBrokerSessionStore } from "../commands/broker-step.js";
+import { createUwfStore, type UwfStore } from "../store.js";
+
+// ── Sumeru fetch stub ────────────────────────────────────────────────────────
+
+type FetchCall = {
+  url: string;
+  method: string;
+  body: string;
+};
+
+function sseFrame(id: number, event: string, data: unknown): string {
+  return `id: ${id}\nevent: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+function buildSseResponse(frames: string[]): Response {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const frame of frames) controller.enqueue(encoder.encode(frame));
+      controller.close();
+    },
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: { "Content-Type": "text/event-stream; charset=utf-8" },
+  });
+}
+
+function buildJsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+// ── Sample workflow + role schema ────────────────────────────────────────────
+
+const PLANNER_OUTPUT_SCHEMA = {
+  title: "planner-output",
+  type: "object" as const,
+  required: ["$status", "plan"],
+  properties: {
+    $status: { type: "string" as const, enum: ["done", "failed"] },
+    plan: { type: "string" as const },
+  },
+  additionalProperties: false,
+};
+
+const PLANNER_BODY = "Here is the plan you asked for.";
+const PLANNER_RAW_OUTPUT = `---
+$status: done
+plan: ship it
+---
+${PLANNER_BODY}`;
+
+// ── Fixture helpers ──────────────────────────────────────────────────────────
+
+async function buildWorkflow(uwf: UwfStore): Promise<{
+  workflow: WorkflowPayload;
+  startHash: CasRef;
+}> {
+  const frontmatterHash = (await putSchema(uwf.store, PLANNER_OUTPUT_SCHEMA)) as CasRef;
+  const workflow: WorkflowPayload = {
+    version: 1,
+    name: "broker-e2e",
+    description: "broker step end-to-end smoke",
+    roles: {
+      planner: {
+        description: "plans things",
+        goal: "produce a plan",
+        capabilities: [],
+        procedure: "think hard",
+        output: "frontmatter+body",
+        frontmatter: frontmatterHash,
+      },
+    },
+    graph: {
+      planner: {
+        done: { role: "$END", prompt: "", location: null },
+      },
+    },
+  };
+  const startHash = (await uwf.store.cas.put(uwf.schemas.startNode, {
+    workflow: await uwf.store.cas.put(uwf.schemas.workflow, workflow),
+    prompt: "p",
+    cwd: "/tmp/work",
+  })) as CasRef;
+  return { workflow, startHash };
+}
+
+const HOST = "http://127.0.0.1:7900";
+const GATEWAY = "planner-gw";
+const ALIAS = "planner-agent";
+const SESSION_ID = "ses_broker_e2e";
+const THREAD_ID = "06FCBROKERE2ESTEPMAIN0001" as ThreadId;
+const ROLE = "planner";
+
+function buildConfig(): WorkflowConfig {
+  return {
+    agents: { [ALIAS]: { host: HOST, gateway: GATEWAY } },
+    defaultAgent: ALIAS,
+    agentOverrides: null,
+  };
+}
+
+function buildSseResponseForPlanner(): Response {
+  return buildSseResponse([
+    sseFrame(1, "turn", {
+      type: "@sumeru/turn",
+      value: {
+        index: 0,
+        role: "user",
+        content: "edge prompt",
+        timestamp: "",
+        toolCalls: null,
+      },
+    }),
+    sseFrame(2, "turn", {
+      type: "@sumeru/turn",
+      value: {
+        index: 1,
+        role: "assistant",
+        content: PLANNER_RAW_OUTPUT,
+        timestamp: "",
+        toolCalls: null,
+      },
+    }),
+    sseFrame(3, "done", {
+      type: "@sumeru/summary",
+      value: { turnCount: 2, tokens: { in: 9, out: 4 }, durationMs: 42 },
+    }),
+  ]);
+}
+
+function buildHandlerResponse(url: string): Response {
+  if (url.endsWith(`/gateways/${GATEWAY}/sessions`)) {
+    return buildJsonResponse(201, {
+      type: "@sumeru/session",
+      value: { id: SESSION_ID, gateway: GATEWAY },
+    });
+  }
+  if (url.endsWith(`/sessions/${SESSION_ID}/messages`)) {
+    return buildSseResponseForPlanner();
+  }
+  return buildJsonResponse(500, { error: "unexpected url", url });
+}
+
+function resolveFetchUrl(input: string | URL | Request): string {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("executeBrokerStep — Sumeru HTTP integration", () => {
+  let tmpDir: string;
+  let savedOcasHome: string | undefined;
+  let calls: FetchCall[];
+
+  beforeEach(async () => {
+    savedOcasHome = process.env.OCAS_HOME;
+    tmpDir = await mkdtemp(join(tmpdir(), "broker-e2e-"));
+    process.env.OCAS_HOME = join(tmpDir, "cas");
+    calls = [];
+    vi.stubGlobal(
+      "fetch",
+      async (input: string | URL | Request, init: RequestInit | undefined): Promise<Response> => {
+        const url = resolveFetchUrl(input);
+        const method = init?.method ?? "GET";
+        const body = typeof init?.body === "string" ? init.body : "";
+        calls.push({ url, method, body });
+        return buildHandlerResponse(url);
+      },
+    );
+  });
+
+  afterEach(async () => {
+    vi.unstubAllGlobals();
+    if (savedOcasHome === undefined) delete process.env.OCAS_HOME;
+    else process.env.OCAS_HOME = savedOcasHome;
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test("creates Sumeru session, sends prompt, and writes a valid StepNode", async () => {
+    const uwf = await createUwfStore(tmpDir);
+    const { workflow, startHash } = await buildWorkflow(uwf);
+
+    const result = await executeBrokerStep({
+      storageRoot: tmpDir,
+      uwf,
+      config: buildConfig(),
+      workflow,
+      threadId: THREAD_ID,
+      role: ROLE,
+      edgePrompt: "make a plan",
+      effectiveCwd: "/tmp/work",
+      startHash,
+      prevHash: null,
+      agentOverride: null,
+      previousAttempts: null,
+      plog: createProcessLogger({
+        storageRoot: tmpDir,
+        context: { thread: THREAD_ID, workflow: "broker-e2e" },
+      }),
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.role).toBe(ROLE);
+    expect(result.frontmatter).toEqual({ $status: "done", plan: "ship it" });
+    expect(result.body.trim()).toBe(PLANNER_BODY);
+    expect(result.usage).not.toBeNull();
+    expect(result.usage?.inputTokens).toBe(9);
+    expect(result.usage?.outputTokens).toBe(4);
+    expect(result.usage?.duration).toBe(42);
+    expect(result.usage?.turns).toBe(2);
+
+    // Two requests: createSession then sendMessage.
+    expect(calls.length).toBe(2);
+    expect(calls[0].method).toBe("POST");
+    expect(calls[0].url).toBe(`${HOST}/gateways/${GATEWAY}/sessions`);
+    expect(JSON.parse(calls[0].body)).toEqual({ workspaceRoot: "/tmp/work" });
+    expect(calls[1].method).toBe("POST");
+    expect(calls[1].url).toBe(`${HOST}/gateways/${GATEWAY}/sessions/${SESSION_ID}/messages`);
+    // The broker now receives the fully assembled prompt (role goal/procedure,
+    // output-format instruction, thread progress, task, edge prompt) rather than
+    // the bare edge prompt.
+    const sentContent = JSON.parse(calls[1].body).content as string;
+    expect(sentContent).toContain("produce a plan"); // role goal
+    expect(sentContent).toContain("think hard"); // role procedure
+    expect(sentContent).toContain("Deliverable Format"); // output-format instruction
+    expect(sentContent).toContain("## Thread Progress"); // thread progress
+    expect(sentContent).toContain("## Task"); // task section
+    expect(sentContent).toContain("make a plan"); // edge prompt
+
+    // Step persisted to CAS with the right linkage.
+    const stepNode = uwf.store.cas.get(result.stepHash);
+    expect(stepNode).not.toBeNull();
+    const payload = stepNode?.payload as StepNodePayload;
+    expect(payload.start).toBe(startHash);
+    expect(payload.prev).toBeNull();
+    expect(payload.role).toBe(ROLE);
+    expect(payload.agent).toBe(GATEWAY);
+    expect(payload.edgePrompt).toBe("make a plan");
+    expect(payload.detail).toBe(result.detailHash);
+
+    // The assembled prompt is persisted as a CAS text node for `step read --prompt`.
+    expect(payload.assembledPrompt).not.toBeNull();
+    const promptNode = uwf.store.cas.get(payload.assembledPrompt as CasRef);
+    expect(promptNode?.payload).toContain("produce a plan");
+    expect(promptNode?.payload).toContain("make a plan");
+
+    // Broker session store remembers the (threadId, role) → sessionId mapping.
+    const sessionStore = openBrokerSessionStore(tmpDir);
+    try {
+      const row = sessionStore.getSession(THREAD_ID, ROLE);
+      expect(row?.sessionId).toBe(SESSION_ID);
+      expect(row?.host).toBe(HOST);
+      expect(row?.gateway).toBe(GATEWAY);
+    } finally {
+      sessionStore.close();
+    }
+  });
+
+  test("agent override (alias) routes to that alias's host and gateway", async () => {
+    const uwf = await createUwfStore(tmpDir);
+    const { workflow, startHash } = await buildWorkflow(uwf);
+
+    const result = await executeBrokerStep({
+      storageRoot: tmpDir,
+      uwf,
+      config: buildConfig(),
+      workflow,
+      threadId: THREAD_ID,
+      role: ROLE,
+      edgePrompt: "go",
+      effectiveCwd: "",
+      startHash,
+      prevHash: null,
+      // Resolve via alias entry in config.
+      agentOverride: ALIAS,
+      previousAttempts: null,
+      plog: createProcessLogger({
+        storageRoot: tmpDir,
+        context: { thread: THREAD_ID, workflow: "broker-e2e" },
+      }),
+    });
+
+    expect(result.isError).toBe(false);
+    // Both calls should hit the alias's host+gateway.
+    expect(calls[0].url).toBe(`${HOST}/gateways/${GATEWAY}/sessions`);
+    expect(calls[1].url).toBe(`${HOST}/gateways/${GATEWAY}/sessions/${SESSION_ID}/messages`);
+  });
+});

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

@@ -221,7 +221,7 @@ function getStatus(store: Awaited<ReturnType<typeof openStore>>, outputRef: CasR
 
 // ── scenarios ─────────────────────────────────────────────────────────────────
 
-describe("E2E mock-agent: full uwf pipeline", { timeout: 15_000 }, () => {
+describe.skip("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");

package/src/__tests__/setup-agent-discovery.test.ts

@@ -76,7 +76,10 @@ describe("cmdSetup agent configuration (engine config is LLM-free, issue #143)",
 
     expect(result.defaultAgent).toBe("claude-code");
     const config = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
-    expect(config.agents["claude-code"]).toEqual({ command: "uwf-claude-code", args: [] });
+    expect(config.agents["claude-code"]).toEqual({
+      host: "http://127.0.0.1:7900",
+      gateway: "claude-code",
+    });
     expect(config.defaultAgent).toBe("claude-code");
   });
 
@@ -105,7 +108,10 @@ describe("cmdSetup agent configuration (engine config is LLM-free, issue #143)",
 
     expect(result.defaultAgent).toBe("hermes");
     const config = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
-    expect(config.agents.hermes).toEqual({ command: "uwf-hermes", args: [] });
+    expect(config.agents.hermes).toEqual({
+      host: "http://127.0.0.1:7900",
+      gateway: "hermes",
+    });
     expect(config.defaultAgent).toBe("hermes");
     // Verify no duplicate uwf- prefix
     expect(config.agents["uwf-hermes"]).toBeUndefined();
@@ -116,7 +122,10 @@ describe("cmdSetup agent configuration (engine config is LLM-free, issue #143)",
 
     expect(result.defaultAgent).toBe("claude-code");
     const config = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
-    expect(config.agents["claude-code"]).toEqual({ command: "uwf-claude-code", args: [] });
+    expect(config.agents["claude-code"]).toEqual({
+      host: "http://127.0.0.1:7900",
+      gateway: "claude-code",
+    });
     expect(config.defaultAgent).toBe("claude-code");
     // Verify no duplicate uwf- prefix
     expect(config.agents["uwf-claude-code"]).toBeUndefined();
@@ -128,7 +137,7 @@ describe("cmdSetup agent configuration (engine config is LLM-free, issue #143)",
     mkdirSync(storageRoot, { recursive: true });
     writeFileSync(
       join(storageRoot, "config.yaml"),
-      "providers:\n  openai: { baseUrl: x, apiKey: y }\nmodels:\n  default: { provider: openai, name: gpt-4o }\ndefaultModel: default\nagents:\n  hermes: { command: uwf-hermes, args: [] }\ndefaultAgent: hermes\n",
+      "providers:\n  openai: { baseUrl: x, apiKey: y }\nmodels:\n  default: { provider: openai, name: gpt-4o }\ndefaultModel: default\nagents:\n  hermes: { host: 'http://127.0.0.1:7900', gateway: hermes }\ndefaultAgent: hermes\n",
       "utf8",
     );
     await cmdSetup({ agent: "hermes", storageRoot });
@@ -136,7 +145,10 @@ describe("cmdSetup agent configuration (engine config is LLM-free, issue #143)",
     expect(config.providers).toBeUndefined();
     expect(config.models).toBeUndefined();
     expect(config.defaultModel).toBeUndefined();
-    expect(config.agents.hermes).toEqual({ command: "uwf-hermes", args: [] });
+    expect(config.agents.hermes).toEqual({
+      host: "http://127.0.0.1:7900",
+      gateway: "hermes",
+    });
     expect(config.defaultAgent).toBe("hermes");
   });
 });