@ryanfw/prompt-orchestration-pipeline 1.3.0 → 1.3.1

package/README.md

@@ -50,6 +50,7 @@ Switch models globally or per-task without rewriting your logic.
     *   **Moonshot** (Kimi)
     *   **Zhipu** (GLM-4)
     *   **Claude Code** (CLI integration)
+*   **CLI Agents**: Tasks can also drive tool-using CLI coding agents (Claude, Codex, OpenCode) via the injected `runAgent()` helper — for file-aware, multi-turn work alongside single LLM calls. See the [Task Development Guide](docs/pop-task-guide.md#agent-api).
 
 ---
 

package/docs/pop-task-guide.md

@@ -192,6 +192,49 @@ const response = await llm.deepseek.chat({
 
 ---
 
+## Agent API
+
+Available via the `runAgent` function passed to stages. It runs a CLI coding
+agent (the harness adapter) from inside a standard JavaScript task — the same
+machinery behind pipeline `agent:` entries, but callable mid-task with a prompt
+you build programmatically from upstream data.
+
+```js
+export const inference = async ({ runAgent, io, data, flags }) => {
+  const result = await runAgent({
+    harness: "claude",        // "claude" | "codex" | "opencode"
+    prompt: "Read 'context.md', then write a summary to 'summary.md'.",
+    // model?: string         // optional, passed through to the CLI
+    // io?: boolean           // default true: bridge POP read/write artifacts
+    // timeoutMs?: number     // optional wall-clock cap
+    // captureDiff?: boolean  // capture a git diff as 'agent.patch'
+  });
+
+  if (!result.ok) {
+    throw new Error(`Agent failed: ${result.error}`);
+  }
+
+  // result: { ok, finalMessage, artifactsWritten, usage?, costUsd?, sessionId? }
+  const summary = await io.readArtifact("summary.md");
+  return { output: { summary }, flags };
+};
+```
+
+By default (`io` is `true`) the agent shares the task's file I/O: it can call the
+`read_artifact` / `write_artifact` tools to read and write the same artifacts the
+task sees, and its `agent-result.md` is written automatically. Token usage and
+cost flow into the job status like any other LLM call.
+
+**`runAgent` vs `llm`**: use `llm.<provider>.chat()` for a single request/response
+LLM call; use `runAgent()` when you need a tool-using CLI agent that reads and
+writes files over multiple turns.
+
+**`runAgent` vs an `agent:` pipeline entry**: an `agent:` entry takes a static
+prompt from `pipeline.json`. `runAgent()` lets a JavaScript task compose the
+prompt from seed/stage data and post-process the result in later stages.
+
+---
+
 ## Validation API
 
 Available via `validators` object in stages that need schema validation.
@@ -320,6 +363,7 @@ Each stage receives:
 {
   io,                    // File I/O (may be null)
   llm,                   // LLM client
+  runAgent,              // Run a CLI agent harness (see Agent API)
   validators,            // { validateWithSchema }
   flags,                 // Control flags
   meta: { taskName, workDir, jobId },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",
@@ -72,7 +72,8 @@
     "tslib": "^2.8.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opencode-ai/sdk": "^1.17.4",
-    "zod": "^3.25.0"
+    "zod": "^3.25.0",
+    "local-llm-cli-adapter": "github:ryan-mahoney/local-llm-cli-adapter#2ea1aa2d8e8dbe43eb845eb4730b08a02618f476"
   },
   "devDependencies": {
     "@eslint/js": "^9.37.0",

package/src/core/__tests__/agent-step.test.ts

@@ -5,11 +5,11 @@ import { tmpdir } from "node:os";
 import type { WriteOptions, TaskFileIO } from "../file-io.ts";
 import type { McpIoServerHandle } from "../../harness/mcp-io-server.ts";
 import type {
-  HarnessRunOptions,
-  HarnessRunResult,
+  RunResult,
+  HarnessRun,
   HarnessEvent,
-} from "../../harness/types.ts";
-import { runAgentStep } from "../agent-step.ts";
+} from "../../harness/index.ts";
+import { runAgentStep, executeAgent } from "../agent-step.ts";
 import { createTaskFileIO } from "../file-io.ts";
 
 function createFakeIO(): TaskFileIO & { calls: string[] } {
@@ -84,26 +84,33 @@ function makeArgs(overrides?: {
   };
 }
 
-function makeSuccessResult(overrides?: Partial<HarnessRunResult>): HarnessRunResult {
+function makeFakeHarnessRun(result: RunResult | Error): HarnessRun {
+  const resolved =
+    result instanceof Error
+      ? Promise.reject(result)
+      : Promise.resolve(result);
+  return {
+    result: resolved,
+    sessionId: Promise.resolve("sess-1"),
+    abort() {},
+  };
+}
+
+function makeSuccessResult(overrides?: Partial<RunResult>): RunResult {
   return {
     finalMessage: "task complete",
-    events: [],
     exitCode: 0,
     usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
-    costUsd: 0.12,
     sessionId: "sess-1",
     ...overrides,
   };
 }
 
-function makeDeps(result: HarnessRunResult | Error) {
-  const runHarnessTask = mock(async (_opts: HarnessRunOptions) => {
-    if (result instanceof Error) throw result;
-    return result;
-  });
+function makeDeps(result: RunResult | Error) {
+  const run = mock(() => makeFakeHarnessRun(result));
   const startMcpIoServer = mock(async () => createFakeMcpHandle());
   const createTaskFileIO = mock(() => createFakeIO());
-  return { runHarnessTask, startMcpIoServer, createTaskFileIO };
+  return { run, startMcpIoServer, createTaskFileIO };
 }
 
 function gitSync(args: string[], cwd: string): string {
@@ -119,13 +126,60 @@ function makeCaptureDeps(workDir: string) {
     statusPath: join(workDir, "tasks-status.json"),
   });
   return {
-    runHarnessTask: mock(async () => makeSuccessResult()),
+    run: mock(() => makeFakeHarnessRun(makeSuccessResult())),
     startMcpIoServer: mock(async () => createFakeMcpHandle()),
     createTaskFileIO: mock(() => io),
     io,
   };
 }
 
+describe("executeAgent", () => {
+  it("runs against a provided io and returns ok:true with merged artifacts", async () => {
+    const io = createFakeIO();
+    const run = mock(() => makeFakeHarnessRun(makeSuccessResult()));
+    const startMcpIoServer = mock(async () => createFakeMcpHandle(["explainer.md"]));
+
+    const result = await executeAgent(
+      { io, entry: { name: "agent-explainer", harness: "claude", prompt: "do it" } },
+      { run, startMcpIoServer },
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.finalMessage).toBe("task complete");
+    expect(result.artifactsWritten).toContain("explainer.md");
+    expect(result.artifactsWritten).toContain("agent-result.md");
+    expect(io.calls).toContain("writeArtifact:agent-result.md");
+    expect(startMcpIoServer).toHaveBeenCalled();
+  });
+
+  it("returns ok:false when the harness run rejects", async () => {
+    const io = createFakeIO();
+    const run = mock(() => makeFakeHarnessRun(new Error("spawn failed")));
+    const startMcpIoServer = mock(async () => createFakeMcpHandle());
+
+    const result = await executeAgent(
+      { io, entry: { name: "agent-explainer", harness: "codex", prompt: "do it" } },
+      { run, startMcpIoServer },
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe("spawn failed");
+  });
+
+  it("skips the MCP server when io is false", async () => {
+    const io = createFakeIO();
+    const run = mock(() => makeFakeHarnessRun(makeSuccessResult()));
+    const startMcpIoServer = mock(async () => createFakeMcpHandle());
+
+    await executeAgent(
+      { io, entry: { name: "a", harness: "opencode", prompt: "p", io: false } },
+      { run, startMcpIoServer },
+    );
+
+    expect(startMcpIoServer).not.toHaveBeenCalled();
+  });
+});
+
 describe("runAgentStep", () => {
   it("success writes event log and agent-result.md and returns ok:true with usage/cost", async () => {
     const deps = makeDeps(makeSuccessResult());
@@ -135,7 +189,7 @@ describe("runAgentStep", () => {
     expect(result.ok).toBe(true);
     expect(result.finalMessage).toBe("task complete");
     expect(result.usage).toEqual({ inputTokens: 100, outputTokens: 50, totalTokens: 150 });
-    expect(result.costUsd).toBe(0.12);
+    expect(result.costUsd).toBeUndefined();
     expect(result.sessionId).toBe("sess-1");
     expect(result.artifactsWritten).toContain("agent-result.md");
     expect(deps.startMcpIoServer).toHaveBeenCalled();
@@ -150,18 +204,18 @@ describe("runAgentStep", () => {
     });
 
     const events: HarnessEvent[] = [
-      { type: "text", raw: { text: "hello" }, text: "hello" },
-      { type: "result", raw: { message: "done" } },
+      { harness: "claude", seq: 0, at: Date.now(), raw: { text: "hello" }, type: "assistant_message", text: "hello" },
+      { harness: "claude", seq: 1, at: Date.now(), raw: { message: "done" }, type: "run_completed", result: makeSuccessResult() },
     ];
-    const runHarnessTask = mock(async (opts: HarnessRunOptions) => {
+    const run = mock((opts: { onEvent?: (event: HarnessEvent) => void }) => {
       for (const event of events) {
         opts.onEvent?.(event);
       }
-      return makeSuccessResult();
+      return makeFakeHarnessRun(makeSuccessResult());
     });
     const startMcpIoServer = mock(async () => createFakeMcpHandle());
 
-    await runAgentStep(makeArgs(), { runHarnessTask, startMcpIoServer, createTaskFileIO });
+    await runAgentStep(makeArgs(), { run, startMcpIoServer, createTaskFileIO });
 
     const logCalls = capturedIO!.calls.filter((c) => c.startsWith("writeLog:"));
     expect(logCalls).toHaveLength(2);
@@ -177,15 +231,15 @@ describe("runAgentStep", () => {
     });
 
     let capturedPrompt: string | undefined;
-    const runHarnessTask = mock(async (opts: HarnessRunOptions) => {
+    const run = mock((opts: { prompt: string }) => {
       capturedPrompt = opts.prompt;
-      return makeSuccessResult();
+      return makeFakeHarnessRun(makeSuccessResult());
     });
     const startMcpIoServer = mock(async () => createFakeMcpHandle());
 
     const result = await runAgentStep(
       makeArgs({ entry: { prompt: undefined, promptFrom: "my-prompt.md" } }),
-      { runHarnessTask, startMcpIoServer, createTaskFileIO },
+      { run, startMcpIoServer, createTaskFileIO },
     );
 
     expect(result.ok).toBe(true);
@@ -197,9 +251,7 @@ describe("runAgentStep", () => {
     const mcpHandle = createFakeMcpHandle();
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => {
-        throw new Error("boom");
-      }),
+      run: mock(() => makeFakeHarnessRun(new Error("boom"))),
       startMcpIoServer: mock(async () => mcpHandle),
       createTaskFileIO,
     };
@@ -216,7 +268,7 @@ describe("runAgentStep", () => {
     const mcpHandle = createFakeMcpHandle();
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => makeSuccessResult()),
+      run: mock(() => makeFakeHarnessRun(makeSuccessResult())),
       startMcpIoServer: mock(async () => mcpHandle),
       createTaskFileIO,
     };
@@ -229,9 +281,7 @@ describe("runAgentStep", () => {
     const mcpHandle = createFakeMcpHandle();
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => {
-        throw new Error("fail");
-      }),
+      run: mock(() => makeFakeHarnessRun(new Error("fail"))),
       startMcpIoServer: mock(async () => mcpHandle),
       createTaskFileIO,
     };
@@ -244,9 +294,7 @@ describe("runAgentStep", () => {
     const mcpHandle = createFakeMcpHandle();
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => {
-        throw new Error('Harness "claude" timed out after 100ms');
-      }),
+      run: mock(() => makeFakeHarnessRun(new Error('Harness "claude" timed out after 100ms'))),
       startMcpIoServer: mock(async () => mcpHandle),
       createTaskFileIO,
     };
@@ -258,7 +306,7 @@ describe("runAgentStep", () => {
   it("does not start MCP server when io is false", async () => {
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => makeSuccessResult()),
+      run: mock(() => makeFakeHarnessRun(makeSuccessResult())),
       startMcpIoServer: mock(async () => createFakeMcpHandle()),
       createTaskFileIO,
     };
@@ -284,7 +332,7 @@ describe("runAgentStep", () => {
     const mcpHandle = createFakeMcpHandle(["custom-artifact.md", "agent-result.md"]);
     const createTaskFileIO = mock(() => createFakeIO());
     const deps = {
-      runHarnessTask: mock(async () => makeSuccessResult()),
+      run: mock(() => makeFakeHarnessRun(makeSuccessResult())),
       startMcpIoServer: mock(async () => mcpHandle),
       createTaskFileIO,
     };

package/src/core/__tests__/task-runner.test.ts

@@ -211,3 +211,51 @@ describe("task-runner writes correct task-level state transitions", () => {
     expect(task!.error).toBe("stage exploded");
   });
 });
+
+describe("runPipeline runAgent injection", () => {
+  it("passes runAgent to stages and delegates to the supplied override", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-agent");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-agent", tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "agent-task.mjs");
+    await writeFile(
+      modulePath,
+      [
+        "export const ingestion = async ({ runAgent, flags }) => {",
+        "  const r = await runAgent({ harness: 'claude', prompt: 'hello agent' });",
+        "  return { output: r, flags };",
+        "};",
+      ].join("\n"),
+    );
+
+    const calls: unknown[] = [];
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "agent-task",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-agent",
+      envLoaded: true,
+      seed: { data: {} },
+      pipelineTasks: ["agent-task"],
+      llm: {} as never,
+      runAgent: async (options) => {
+        calls.push(options);
+        return { ok: true, finalMessage: "did it", artifactsWritten: ["x.md"] };
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(calls).toEqual([{ harness: "claude", prompt: "hello agent" }]);
+    if (result.ok) {
+      expect(result.context.data["ingestion"]).toMatchObject({
+        ok: true,
+        finalMessage: "did it",
+      });
+    }
+  });
+});

package/src/core/agent-step.ts

@@ -3,14 +3,11 @@ import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { createTaskFileIO, generateLogName } from "./file-io.ts";
 import { LogEvent, LogFileExtension } from "../config/log-events.ts";
-import { runHarnessTask } from "../harness/executor.ts";
+import { run } from "../harness/index.ts";
 import { startMcpIoServer } from "../harness/mcp-io-server.ts";
 import type { McpIoServerHandle } from "../harness/mcp-io-server.ts";
-import type {
-  AgentEntryConfig,
-  AgentStepResult,
-  HarnessEvent,
-} from "../harness/types.ts";
+import type { AgentEntryConfig, AgentStepResult } from "./agent-types.ts";
+import type { RunOptions, HarnessRun, HarnessEvent } from "../harness/index.ts";
 import type { TaskFileIO } from "./file-io.ts";
 
 function gitSync(args: string[], cwd: string): { exitCode: number; stdout: string; stderr: string } {
@@ -65,78 +62,88 @@ async function captureDiff(io: TaskFileIO, cwd: string): Promise<boolean> {
   }
 }
 
-export async function runAgentStep(
+/** Dependency seam shared by the agent runners (injected in tests). */
+interface AgentRunDeps {
+  run?: typeof run;
+  startMcpIoServer?: typeof startMcpIoServer;
+}
+
+/**
+ * Runs a single CLI-agent harness step against an existing task `io`.
+ *
+ * This is the shared core behind both pipeline `agent:` entries (via
+ * {@link runAgentStep}) and the `runAgent()` helper injected into standard
+ * JavaScript task stages (via the task runner). The caller owns the `io`, so
+ * the agent reads and writes the same task artifacts the surrounding task sees.
+ */
+export async function executeAgent(
   args: {
+    io: TaskFileIO;
     entry: AgentEntryConfig & { name: string };
-    workDir: string;
-    statusPath: string;
-    jobId: string | undefined;
-    getStage: () => string;
-  },
-  deps?: {
-    runHarnessTask?: typeof runHarnessTask;
-    startMcpIoServer?: typeof startMcpIoServer;
-    createTaskFileIO?: typeof createTaskFileIO;
   },
+  deps?: AgentRunDeps,
 ): Promise<AgentStepResult> {
-  const _runHarnessTask = deps?.runHarnessTask ?? runHarnessTask;
+  const _run = deps?.run ?? run;
   const _startMcpIoServer = deps?.startMcpIoServer ?? startMcpIoServer;
-  const _createTaskFileIO = deps?.createTaskFileIO ?? createTaskFileIO;
+  const { io, entry } = args;
 
-  const io = _createTaskFileIO({
-    workDir: args.workDir,
-    taskName: args.entry.name,
-    getStage: args.getStage,
-    statusPath: args.statusPath,
-  });
-
-  const cwd = args.entry.cwd ?? io.getTaskDir();
+  const cwd = entry.cwd ?? io.getTaskDir();
   // The harness spawns with this cwd before any artifact is written, so the task
   // dir may not exist yet — posix_spawn ENOENTs on a missing working directory.
   await mkdir(cwd, { recursive: true });
 
   let prompt: string;
-  if (args.entry.prompt !== undefined) {
-    prompt = args.entry.prompt;
-  } else if (args.entry.promptFrom !== undefined) {
-    prompt = await io.readArtifact(args.entry.promptFrom);
+  if (entry.prompt !== undefined) {
+    prompt = entry.prompt;
+  } else if (entry.promptFrom !== undefined) {
+    prompt = await io.readArtifact(entry.promptFrom);
   } else {
     throw new Error(
-      `Agent entry "${args.entry.name}" must specify either "prompt" or "promptFrom"`,
+      `Agent entry "${entry.name}" must specify either "prompt" or "promptFrom"`,
     );
   }
 
   let mcpHandle: McpIoServerHandle | undefined;
-  if (args.entry.io !== false) {
+  if (entry.io !== false) {
     mcpHandle = await _startMcpIoServer(io);
   }
 
   try {
     const logName = generateLogName(
-      args.entry.name,
+      entry.name,
       "agent",
       LogEvent.DEBUG,
       LogFileExtension.TEXT,
     );
 
-    const result = await _runHarnessTask({
-      harness: args.entry.harness,
+    const options: RunOptions = {
+      harness: entry.harness,
       prompt,
       cwd,
-      model: args.entry.model,
-      mcp: mcpHandle?.connection,
-      timeoutMs: args.entry.timeoutMs,
+      model: entry.model,
+      mcpServers: mcpHandle
+        ? [{
+            name: "popio",
+            url: mcpHandle.connection.url,
+            headers: { Authorization: `Bearer ${mcpHandle.connection.token}` },
+          }]
+        : undefined,
+      timeoutMs: entry.timeoutMs,
+      permissionMode: "bypass",
       onEvent: (event: HarnessEvent) => {
         void io.writeLog(logName, JSON.stringify(event.raw) + "\n", {
           mode: "append",
         });
       },
-    });
+    };
+
+    const harnessRun: HarnessRun = _run(options);
+    const result = await harnessRun.result;
 
     await io.writeArtifact("agent-result.md", result.finalMessage);
 
     let patchWritten = false;
-    if (args.entry.captureDiff) {
+    if (entry.captureDiff) {
       patchWritten = await captureDiff(io, cwd);
     }
 
@@ -171,3 +178,33 @@ export async function runAgentStep(
     }
   }
 }
+
+/**
+ * Runs a CLI-agent harness step for a pipeline `agent:` entry.
+ *
+ * Creates a task-scoped `io` from the run paths, then delegates to
+ * {@link executeAgent}. Used by the pipeline runner for `agent` entries.
+ */
+export async function runAgentStep(
+  args: {
+    entry: AgentEntryConfig & { name: string };
+    workDir: string;
+    statusPath: string;
+    jobId: string | undefined;
+    getStage: () => string;
+  },
+  deps?: AgentRunDeps & {
+    createTaskFileIO?: typeof createTaskFileIO;
+  },
+): Promise<AgentStepResult> {
+  const _createTaskFileIO = deps?.createTaskFileIO ?? createTaskFileIO;
+
+  const io = _createTaskFileIO({
+    workDir: args.workDir,
+    taskName: args.entry.name,
+    getStage: args.getStage,
+    statusPath: args.statusPath,
+  });
+
+  return executeAgent({ io, entry: args.entry }, deps);
+}

package/src/core/agent-types.ts

@@ -0,0 +1,58 @@
+import type { HarnessName, Usage } from "../harness/index.ts";
+
+export interface McpServerConnection {
+  url: string;
+  token: string;
+}
+
+export interface AgentEntryConfig {
+  harness: HarnessName;
+  model?: string;
+  prompt?: string;
+  promptFrom?: string;
+  cwd?: string;
+  io?: boolean;
+  timeoutMs?: number;
+  captureDiff?: boolean;
+}
+
+export interface AgentStepResult {
+  ok: boolean;
+  finalMessage: string;
+  artifactsWritten: string[];
+  usage?: Usage;
+  costUsd?: number;
+  sessionId?: string;
+  error?: string;
+}
+
+/**
+ * Options for the `runAgent()` helper injected into standard JavaScript task
+ * stages. Mirrors {@link AgentEntryConfig} but requires an inline `prompt`
+ * (a task builds the prompt programmatically rather than reading it from an
+ * artifact via `promptFrom`).
+ */
+export interface TaskAgentOptions {
+  /** Which CLI agent to run: `"claude" | "codex" | "opencode"`. */
+  harness: HarnessName;
+  /** The instruction handed to the agent. */
+  prompt: string;
+  /** Optional model id passed through to the harness verbatim. */
+  model?: string;
+  /** Working directory for the agent. Defaults to the task directory. */
+  cwd?: string;
+  /**
+   * Bridge POP file I/O into the agent (read_artifact/write_artifact tools).
+   * Defaults to `true` so the agent shares the task's artifacts.
+   */
+  io?: boolean;
+  /** Overall wall-clock cap in milliseconds. */
+  timeoutMs?: number;
+  /** Capture a git diff of the working tree as an `agent.patch` artifact. */
+  captureDiff?: boolean;
+}
+
+/** The `runAgent()` function injected into JavaScript task stages. */
+export type TaskAgentRunner = (
+  options: TaskAgentOptions,
+) => Promise<AgentStepResult>;

package/src/core/orchestrator.ts

@@ -112,7 +112,8 @@ import { buildReexecArgs } from "../cli/self-reexec";
 import { writeJobStatus } from "./status-writer";
 import { initializeStatusFromArtifacts } from "./status-initializer";
 import { materializeNormalizedPipelineDefinition } from "./pipeline-definition";
-import { applyHarnessDiscovery, discoverHarnesses } from "../harness/resolve";
+import { discoverHarnesses } from "../harness/index.ts";
+import { applyHarnessDiscovery } from "../harness/discovery.ts";
 import {
   listQueuedSeeds,
   releaseJobSlot,

package/src/core/pipeline-definition.ts

@@ -1,6 +1,6 @@
 import { dirname } from "node:path";
 import { mkdir } from "node:fs/promises";
-import type { AgentEntryConfig } from "../harness/types";
+import type { AgentEntryConfig } from "./agent-types.ts";
 
 export interface PipelineTaskEntry {
   name: string;