@eigenpal/cli 0.6.9 → 0.6.10

package/dist/cli.js

@@ -19715,7 +19715,7 @@ function executionWallClockMs(startedAt, completedAt) {
   const ms = end - start;
   return ms >= 0 ? ms : null;
 }
-var DURABLE_EXECUTION_TYPES, EXECUTION_STATUSES, EXECUTION_PHASES, EXECUTION_PHASE_ORDER, EXECUTION_PHASE_STATUSES, EXECUTION_FAILURE_CATEGORIES, TERMINAL_EXECUTION_STATUSES, TERMINAL_STATUS_SET, EXECUTION_NON_TERMINAL_STATUSES, NON_SUCCESS_TERMINAL_EXECUTION_STATUSES, NON_SUCCESS_TERMINAL_SET, EXECUTION_CONCURRENCY_ACTIVE_STATUSES, EXECUTION_SHARED_CANCEL_REQUESTABLE_STATUSES, EXECUTION_AGENT_CANCEL_REQUESTABLE_STATUSES, EXECUTION_AGENT_QUEUED_STATUSES, EXECUTION_AGENT_REAP_SCAN_STATUSES, EXECUTION_AGENT_METRICS_STATUSES, EXECUTION_EVAL_RUNNING_STATUSES, EXECUTION_FAILED_OR_CANCELLED_STATUSES;
+var DURABLE_EXECUTION_TYPES, RUNS_TRIGGERED_BY_SYSTEM = "__system__", EXECUTION_STATUSES, EXECUTION_PHASES, EXECUTION_PHASE_ORDER, EXECUTION_PHASE_STATUSES, EXECUTION_FAILURE_CATEGORIES, TERMINAL_EXECUTION_STATUSES, TERMINAL_STATUS_SET, EXECUTION_NON_TERMINAL_STATUSES, NON_SUCCESS_TERMINAL_EXECUTION_STATUSES, NON_SUCCESS_TERMINAL_SET, EXECUTION_CONCURRENCY_ACTIVE_STATUSES, EXECUTION_SHARED_CANCEL_REQUESTABLE_STATUSES, EXECUTION_AGENT_CANCEL_REQUESTABLE_STATUSES, EXECUTION_AGENT_QUEUED_STATUSES, EXECUTION_AGENT_REAP_SCAN_STATUSES, EXECUTION_AGENT_METRICS_STATUSES, EXECUTION_EVAL_RUNNING_STATUSES, EXECUTION_FAILED_OR_CANCELLED_STATUSES;
 var init_execution_row = __esm(() => {
   DURABLE_EXECUTION_TYPES = ["workflow", "agent"];
   EXECUTION_STATUSES = [
@@ -66958,6 +66958,7 @@ __export(exports_src, {
   S3_PATH_GRAMMAR: () => S3_PATH_GRAMMAR,
   RootSourceManifestSchema: () => RootSourceManifestSchema,
   ReleaseTagSchema: () => ReleaseTagSchema,
+  RUNS_TRIGGERED_BY_SYSTEM: () => RUNS_TRIGGERED_BY_SYSTEM,
   ProcessorPortSchema: () => ProcessorPortSchema,
   ProcessorExecutionContextSchema: () => ProcessorExecutionContextSchema,
   ProcessorDefinitionSchema: () => ProcessorDefinitionSchema,
@@ -188771,7 +188772,7 @@ import { fileURLToPath as fileURLToPath6 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.6.9",
+  version: "0.6.10",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -191301,7 +191302,7 @@ function registerAgentSourceCommands(agent) {
   withBaseUrl(agent.command("clone")).description("Clone the organization source repository.").option("--out <dir>", "Output directory").option("--tenant-id <tenantId>", "Target tenant id for admin-token source clones").action(action(cloneSource));
   withBaseUrl(agent.command("install [packageRef]")).description("Materialize a source package and its workspace dependencies.").option("--out <dir>", "Output directory for an explicit package ref").option("--lockfile <path>", "Lockfile path").option("--frozen-lockfile", "Install exactly from the existing lockfile").option("--remote-url <url>", "Use an explicit organization Git remote URL").action(action(install));
   registerSourceInitCommand(agent);
-  withBaseUrl(agent.command("pull")).description("Pull organization source from origin/main with --ff-only. For datasets use agents dataset pull; for run artifacts use agents runs artifacts fetch.").option("--dir <dir>", "Repository directory").action(action(pullSource));
+  withBaseUrl(agent.command("pull")).description("Pull organization source from origin/main with --ff-only. For datasets use agents dataset pull; for run artifacts use runs artifacts fetch.").option("--dir <dir>", "Repository directory").action(action(pullSource));
   withBaseUrl(agent.command("commit")).description("Validate changed source packages and commit them.").addOption(new Option("-m, --message <message>", "Commit message").makeOptionMandatory()).option("--dir <dir>", "Repository directory").action(action(commitSource));
   withBaseUrl(agent.command("save")).description("Validate, commit if dirty, and push the current source branch.").option("-m, --message <message>", "Commit message when source changes are dirty").option("--dir <dir>", "Repository directory").action(action(saveSource));
   withBaseUrl(agent.command("push")).description("Push the current organization source branch and tags.").option("--dir <dir>", "Repository directory").action(action(pushSource));
@@ -191322,12 +191323,240 @@ function registerGitCommands(program2) {
   credentialHelper.hidden = true;
 }
 
-// src/commands/agents/dataset.ts
+// src/commands/runs.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { promises as fs3, readFileSync as readFileSync7 } from "node:fs";
 import path8 from "node:path";
 
-// src/commands/agents/shared.ts
-import { existsSync as existsSync6, promises as fs } from "node:fs";
+// src/lib/resolve-workflow.ts
+var WORKFLOW_ID_PREFIX = "wf_";
+function looksLikeWorkflowId(value) {
+  return value.startsWith(WORKFLOW_ID_PREFIX);
+}
+function levenshtein(a, b2, maxDistance) {
+  if (a === b2)
+    return 0;
+  if (Math.abs(a.length - b2.length) > maxDistance)
+    return maxDistance + 1;
+  if (a.length === 0 || b2.length === 0)
+    return a.length || b2.length;
+  const prev = new Array(b2.length + 1);
+  const curr = new Array(b2.length + 1);
+  for (let j3 = 0;j3 <= b2.length; j3++)
+    prev[j3] = j3;
+  for (let i = 1;i <= a.length; i++) {
+    curr[0] = i;
+    let minRow = curr[0];
+    for (let j3 = 1;j3 <= b2.length; j3++) {
+      const cost = a[i - 1] === b2[j3 - 1] ? 0 : 1;
+      curr[j3] = Math.min(prev[j3] + 1, curr[j3 - 1] + 1, prev[j3 - 1] + cost);
+      if (curr[j3] < minRow)
+        minRow = curr[j3];
+    }
+    if (minRow > maxDistance)
+      return maxDistance + 1;
+    for (let j3 = 0;j3 <= b2.length; j3++)
+      prev[j3] = curr[j3];
+  }
+  return prev[b2.length];
+}
+async function findSimilarSlug(client, slug) {
+  try {
+    const res = await client.get("/api/v1/workflows", {
+      search: slug,
+      limit: "20"
+    });
+    const candidates = (res.data ?? []).map((w3) => w3.name).filter((n) => typeof n === "string" && n.length > 0);
+    let best = null;
+    for (const candidate of candidates) {
+      const distance = levenshtein(candidate, slug, 2);
+      if (distance <= 2 && (best === null || distance < best.distance)) {
+        best = { name: candidate, distance };
+      }
+    }
+    return best?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+function notFound(idOrSlug, suggestion) {
+  const base = `Workflow "${idOrSlug}" not found on the server.`;
+  const action2 = "Push it first, or run `eigenpal workflow list` to see what's available.";
+  return new Error(suggestion ? `${base} Did you mean "${suggestion}"? ${action2}` : `${base} ${action2}`);
+}
+async function resolveWorkflowId(client, idOrSlug) {
+  if (looksLikeWorkflowId(idOrSlug)) {
+    try {
+      const wf = await client.get(`/api/v1/workflows/${idOrSlug}`);
+      return wf.id;
+    } catch {
+      throw notFound(idOrSlug, null);
+    }
+  }
+  const res = await client.get("/api/v1/workflows", { name: idOrSlug });
+  const match = res.data?.[0];
+  if (!match) {
+    const suggestion = await findSimilarSlug(client, idOrSlug);
+    throw notFound(idOrSlug, suggestion);
+  }
+  return match.id;
+}
+
+// src/lib/watch.ts
+var TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "rejected"]);
+var STATUS_BADGES = {
+  pending: "[ ]",
+  running: "[..]",
+  completed: "[ok]",
+  failed: "[x]",
+  cancelled: "[-]",
+  skipped: "[s]"
+};
+function statusBadge(status) {
+  return STATUS_BADGES[status] ?? `[${status.slice(0, 3)}]`;
+}
+function durationSuffix(ms) {
+  const formatted = formatDuration(ms);
+  return formatted ? `  ${formatted}` : "";
+}
+function renderFrame(snapshot) {
+  const lines = [
+    `${statusBadge(snapshot.status)} ${snapshot.id}${durationSuffix(snapshot.durationMs)}`
+  ];
+  for (const step of snapshot.stepExecutions ?? []) {
+    const errSuffix = step.error ? `  err: ${step.error.slice(0, 80)}` : "";
+    lines.push(`  ${statusBadge(step.status)} ${step.stepName}${durationSuffix(step.durationMs)}${errSuffix}`);
+    if (step.outputPreview) {
+      lines.push(`     ↳ ${step.outputPreview}`);
+    }
+  }
+  if (snapshot.error && (snapshot.stepExecutions ?? []).length === 0) {
+    lines.push(`  err: ${snapshot.error.slice(0, 200)}`);
+  }
+  return lines.join(`
+`);
+}
+var ANSI_CURSOR_UP = "\x1B[A";
+var ANSI_CLEAR_LINE = "\x1B[2K\r";
+function makeAnsiRenderer() {
+  const isTty = Boolean(process.stderr.isTTY);
+  let previousLineCount = 0;
+  return (frame) => {
+    let buf = "";
+    if (isTty) {
+      for (let i = 0;i < previousLineCount; i++) {
+        buf += i === 0 ? ANSI_CLEAR_LINE : `${ANSI_CURSOR_UP}${ANSI_CLEAR_LINE}`;
+      }
+    }
+    buf += frame;
+    if (!frame.endsWith(`
+`))
+      buf += `
+`;
+    if (!isTty && previousLineCount > 0)
+      buf += `
+`;
+    process.stderr.write(buf);
+    previousLineCount = frame.split(`
+`).length;
+  };
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function snapshotsDiffer(a, b2) {
+  if (a.status !== b2.status)
+    return true;
+  const aSteps = a.stepExecutions ?? [];
+  const bSteps = b2.stepExecutions ?? [];
+  if (aSteps.length !== bSteps.length)
+    return true;
+  for (let i = 0;i < aSteps.length; i++) {
+    if (aSteps[i].stepName !== bSteps[i].stepName || aSteps[i].status !== bSteps[i].status) {
+      return true;
+    }
+  }
+  return false;
+}
+function defaultShouldAbort(err) {
+  return err instanceof ApiError && err.status >= 400 && err.status < 500;
+}
+async function watchExecution(opts) {
+  const sleep = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? (() => Date.now());
+  const render = opts.render ?? makeAnsiRenderer();
+  const maxMs = opts.maxMs ?? 30 * 60 * 1000;
+  const transitionInterval = opts.transitionIntervalMs ?? 2000;
+  const steadyInterval = opts.steadyIntervalMs ?? 5000;
+  const shouldAbort = opts.shouldAbort ?? defaultShouldAbort;
+  const start = now();
+  let previous;
+  let lastFetched;
+  while (true) {
+    let current;
+    try {
+      current = await opts.fetch();
+    } catch (err) {
+      if (shouldAbort(err))
+        throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      render(`(network) ${message.slice(0, 120)}`);
+      if (lastFetched && now() - start >= maxMs) {
+        return { final: lastFetched, detached: true };
+      }
+      await sleep(steadyInterval);
+      continue;
+    }
+    lastFetched = current;
+    render(renderFrame(current));
+    if (TERMINAL_STATUSES.has(current.status)) {
+      return { final: current, detached: false };
+    }
+    if (now() - start >= maxMs) {
+      return { final: current, detached: true };
+    }
+    const transitioned = previous == null || snapshotsDiffer(previous, current);
+    previous = current;
+    await sleep(transitioned ? transitionInterval : steadyInterval);
+  }
+}
+
+// src/commands/agents/run-form-data.ts
+import { promises as fs } from "node:fs";
 import path6 from "node:path";
+async function buildAgentExecutionRunFormData(inputFile, inputJson) {
+  const form = new FormData;
+  for (const spec of parseAgentInputFileSpecs(inputFile)) {
+    const data = await fs.readFile(spec.filePath);
+    form.append(spec.fieldName, new Blob([data]), path6.basename(spec.filePath));
+  }
+  if (inputJson)
+    form.append("_json", inputJson);
+  return form;
+}
+function parseAgentInputFileSpecs(inputFile) {
+  const values = Array.isArray(inputFile) ? inputFile : [inputFile];
+  return values.map((value) => {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex === -1) {
+      return { fieldName: "file", filePath: value };
+    }
+    const fieldName = value.slice(0, separatorIndex).trim();
+    const filePath = value.slice(separatorIndex + 1).trim();
+    if (!fieldName || !filePath) {
+      throw new Error("--input-file must be <field=path> or a bare path");
+    }
+    if (fieldName === "_json" || fieldName === "_metadata" || fieldName === "input") {
+      throw new Error(`--input-file field "${fieldName}" is reserved`);
+    }
+    return { fieldName, filePath };
+  });
+}
+
+// src/commands/agents/shared.ts
+import { existsSync as existsSync6, promises as fs2 } from "node:fs";
+import path7 from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 var PACKAGE_MANIFEST = "eigenpal.yaml";
 var DATASET_DIR = "dataset";
@@ -191351,17 +191580,17 @@ async function readFilesUnder(dir) {
     return [];
   const out = [];
   async function walk(current) {
-    for (const entry of await fs.readdir(current, { withFileTypes: true })) {
+    for (const entry of await fs2.readdir(current, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      const absolute = path6.join(current, entry.name);
+      const absolute = path7.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(absolute);
       } else if (entry.isFile()) {
-        const relative = path6.relative(dir, absolute).split(path6.sep).join("/");
+        const relative = path7.relative(dir, absolute).split(path7.sep).join("/");
         out.push({
           path: relative,
-          contentBase64: (await fs.readFile(absolute)).toString("base64")
+          contentBase64: (await fs2.readFile(absolute)).toString("base64")
         });
       }
     }
@@ -191370,13 +191599,13 @@ async function readFilesUnder(dir) {
   return out;
 }
 async function writeBase64File(file2, contentBase64) {
-  await fs.mkdir(path6.dirname(file2), { recursive: true });
-  await fs.writeFile(file2, Buffer.from(contentBase64, "base64"));
+  await fs2.mkdir(path7.dirname(file2), { recursive: true });
+  await fs2.writeFile(file2, Buffer.from(contentBase64, "base64"));
 }
 async function pollRun(client, executionId, interval, maxWait) {
   const started = Date.now();
   for (;; ) {
-    const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`);
+    const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}?include=detail`);
     if (isTerminal(payload.run?.status))
       return payload;
     if (Date.now() - started > maxWait * 1000) {
@@ -191470,44 +191699,1037 @@ function toCsv(rows, columns) {
 `);
 }
 
+// src/commands/agents/target.ts
+init_src();
+function parseAgentTarget(target) {
+  const [rawTarget, rawRef, extra] = target.split("@");
+  if (extra !== undefined)
+    throw new Error("Agent target must be <slug>[@ref].");
+  const normalizedTarget = rawTarget.includes(".") ? target : `agents.${rawTarget}${rawRef !== undefined ? `@${rawRef}` : ""}`;
+  const parsed = parseAutomationTarget(normalizedTarget);
+  if (parsed.type !== "agents") {
+    throw new Error("Only agent targets are supported in this release. Use agents.<slug>[@ref].");
+  }
+  return {
+    packageName: parsed.packageName,
+    slug: parsed.slug,
+    sourceRef: rawRef !== undefined ? parsed.ref : undefined
+  };
+}
+
+// src/commands/runs.ts
+function registerRunsCommands(program2) {
+  const runs = program2.command("runs").description("Inspect, watch, and manage workflow, agent, and eval runs.").action(() => {
+    process.stderr.write("`eigenpal runs` requires a subcommand. Run `eigenpal runs --help`.\n");
+    process.exit(2);
+  });
+  const listRunsCmd = addJsonFlag(withPagination(withBaseUrl(runs.command("list [source]")), 50)).alias("ls").description("List runs across workflows and agents, optionally scoped to one source.").option("--type <type>", "Filter by run type: workflow|agent").option("--status <status>", "Filter by run status").option("--source-ref <ref>", "Filter agent runs by source ref").option("--batch-id <id>", "Filter eval/experiment runs by batch id").option("--example-id <id>", "Filter eval runs by example id").option("--example-id-contains <text>", "Filter eval runs by example id substring").option("--from <date>", "Created at or after this ISO timestamp or relative date").option("--to <date>", "Created before this ISO timestamp or relative date").option("--created-after <date>", "Alias for --from").option("--created-before <date>", "Alias for --to").option("--completed-after <date>", "Completed at or after this ISO timestamp or relative date").option("--completed-before <date>", "Completed before this ISO timestamp or relative date").option("--compact", "Render compact run rows").option("--sort <field>", "Sort field; only createdAt is supported").option("--order <asc|desc>", "Sort order; only desc is supported");
+  listRunsCmd.action(action(listRuns));
+  addJsonFlag(withBaseUrl(runs.command("get <run-id>"))).description("Get one run.").option("--step <name>", "For workflow runs, show only this step (or comma-separated list)").option("--include <parts>", "Comma-separated extra parts or workflow step fields: feedback,expected,files,trace,issues,input,output,error,duration,inputRef", "feedback").action(action(getRun));
+  addJsonFlag(withBaseUrl(runs.command("compare <reference-run-id> <run-id>"))).description("Compare one run against another run. PDF/DOCX text comparison uses pdftotext/python3 and reports byte fallbacks.").option("--baseline", "Compare actual outputs from both runs instead of expected artifacts").option("--step <name>", "For workflow runs, restrict comparison to one step").option("--out <dir>", "Write comparison artifacts to this directory").option("--normalize-dates", "Normalize YYYYMMDD and YYYY-MM-DD tokens in filenames/text").option("--fail-on-diff", "Exit 1 when comparison status is fail").action(action(compareRun));
+  addJsonFlag(withBaseUrl(runs.command("rerun <run-id>"))).description("Create a new run from a previous run's stored input snapshot.").option("--source-ref <ref>", "Source ref for the new run: latest (default) or original. Workflow runs support only latest/original.").option("--wait", "Poll until the rerun reaches a terminal status").option("--interval <seconds>", "Polling interval in seconds", intArg, 2).option("--max-wait <seconds>", "Maximum wait before exiting 2", intArg, 1800).action(action(rerunRun));
+  const artifacts = runs.command("artifacts").description("Inspect agent run artifacts.").action(() => {
+    process.stderr.write("`eigenpal runs artifacts` requires a subcommand. Run `eigenpal runs artifacts --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(artifacts.command("list <run-id>"))).description("List available agent run artifacts without downloading them.").action(action(listRunArtifacts));
+  withBaseUrl(artifacts.command("fetch <run-id>")).description("Download agent run artifacts by canonical artifact path.").option("--out <dir>", "Output directory").option("--include <parts>", "Comma-separated parts: output,input,metadata,issues,trace,lockfile,expected,all", "all").option("--path <path>", "Fetch one exact artifact path from `artifacts list`; repeatable", collectRepeated, []).option("--json", "Output a JSON summary of written artifacts").action(action(fetchRunArtifacts));
+  withBaseUrl(runs.command("trace <run-id>")).description("Print raw trace.jsonl for a run, or write it with --out.").option("--out <file>", "Output file path").action(action(traceRun));
+  registerRunFeedbackCommands(runs);
+  registerRunExpectedCommands(runs);
+  addJsonFlag(withBaseUrl(runs.command("watch <run-id>"))).description("Watch a run until it reaches a terminal status.").option("--interval <seconds>", "Polling interval in seconds", intArg, 2).option("--max-wait <seconds>", "Maximum wait before exiting 2", intArg, 1800).action(action(watchRunCommand));
+  addJsonFlag(withBaseUrl(runs.command("resume <run-id>"))).description("Resume a workflow run that is waiting for approval.").action(action(resumeRun));
+  addJsonFlag(withBaseUrl(runs.command("cancel <run-id>"))).description("Cancel a run.").option("--yes", "Required in non-interactive environments").action(action(cancelRun));
+}
+function registerRunFeedbackCommands(runs) {
+  const feedback = runs.command("feedback").description("Update or clear feedback attached to a run.").action(() => {
+    process.stderr.write("`eigenpal runs feedback` requires a subcommand. Run `eigenpal runs feedback --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(feedback.command("update <run-id>"))).description("Edit feedback state, rating, message, or expected JSON for a run.").option("--status <open|resolved|ignored>", "Set feedback status").option("--rating <pass|fail|partial|none>", "Set feedback rating").option("--message <text>", "Set feedback message body").option("--message-file <path>", "Read feedback message body from a file").option("--expected-json <json>", "Set structured expected JSON").option("--expected-json-file <path>", "Read structured expected JSON from a file").option("--clear-message", "Clear the feedback message body").option("--clear-rating", "Clear feedback rating").option("--clear-expected-json", "Delete structured expected JSON").action(action(updateRunFeedback));
+  addJsonFlag(withBaseUrl(feedback.command("resolve <run-id>"))).description("Mark run feedback as resolved.").option("--message <text>", "Set feedback message body").option("--message-file <path>", "Read feedback message body from a file").action(action((runId, opts) => updateRunFeedback(runId, { ...opts, status: "resolved" })));
+  addJsonFlag(withBaseUrl(feedback.command("clear <run-id>"))).description("Delete feedback, expected.json, and expected files for a run.").option("--yes", "Required in non-interactive environments").action(action(clearRunFeedback));
+}
+function registerRunExpectedCommands(runs) {
+  const expected = runs.command("expected").description("Manage expected artifacts attached to a run.").action(() => {
+    process.stderr.write("`eigenpal runs expected` requires a subcommand. Run `eigenpal runs expected --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(expected.command("list <run-id>"))).description("List expected JSON and files attached to a run.").action(action(listRunExpected));
+  withBaseUrl(expected.command("pull <run-id>")).description("Download expected JSON and files attached to a run.").option("--out <dir>", "Output directory").action(action(pullRunExpected));
+  addJsonFlag(withBaseUrl(expected.command("upload <run-id> <file>"))).description("Upload a local file as an expected artifact.").option("--name <name>", "Expected artifact name").action(action(uploadRunExpected));
+  addJsonFlag(withBaseUrl(expected.command("copy-output <run-id> <output-file>"))).description("Copy a generated output file into expected artifacts.").option("--name <name>", "Expected artifact name").action(action(copyOutputToExpected));
+  addJsonFlag(withBaseUrl(expected.command("rename <run-id> <old-name> <new-name>"))).description("Rename an expected artifact.").action(action(renameRunExpected));
+  addJsonFlag(withBaseUrl(expected.command("delete <run-id> <name>"))).description("Delete an expected artifact.").option("--yes", "Required in non-interactive environments").action(action(deleteRunExpected));
+}
+async function runExecution(agentId, opts) {
+  const client = buildClient(opts);
+  const runPath = `/api/v1/agents/${encodeURIComponent(agentId)}/run${opts.sourceRef ? `?sourceRef=${encodeURIComponent(opts.sourceRef)}` : ""}`;
+  let payload;
+  if (opts.inputFile && opts.inputFile.length > 0) {
+    const form = await buildAgentExecutionRunFormData(opts.inputFile, opts.inputJson);
+    payload = await client.postFormData(runPath, form);
+  } else {
+    payload = await client.post(runPath, {
+      input: opts.inputJson ? JSON.parse(opts.inputJson) : {},
+      ...opts.sourceRef ? { sourceRef: opts.sourceRef } : {}
+    });
+  }
+  const runId = String(payload.runId ?? "");
+  let waitedForTerminalRun = false;
+  if (opts.wait && runId) {
+    payload = await pollRun(client, runId, opts.interval ?? 2, opts.maxWait ?? 1800);
+    waitedForTerminalRun = true;
+  }
+  renderRunPayload(payload, opts);
+  if (waitedForTerminalRun)
+    setExitCodeForFailedTerminalRun(payload);
+}
+async function runExample(agentId, opts) {
+  const client = buildClient(opts);
+  const started = await client.post(`/api/v1/agents/${encodeURIComponent(agentId)}/experiments`, {
+    exampleId: opts.example,
+    ...opts.sourceRef ? { sourceRef: opts.sourceRef } : {}
+  });
+  const runId = started.runs?.[0]?.runId;
+  if (opts.wait && runId) {
+    const payload2 = await pollRun(client, runId, opts.interval, opts.maxWait);
+    renderRunPayload(payload2, opts);
+    setExitCodeForFailedTerminalRun(payload2);
+    return;
+  }
+  const payload = {
+    runId,
+    exampleId: opts.example,
+    batchId: started.batchId,
+    status: "pending"
+  };
+  if (opts.json)
+    return printJson(payload);
+  success2(`Run ${runId ?? ""} queued for example ${opts.example}`);
+}
+async function getRun(executionId, opts) {
+  const client = buildClient(opts);
+  const include = opts.include ? `detail,${opts.include}` : "detail";
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include
+  });
+  const run = payload.run;
+  if (!run)
+    return renderRunPayload(payload, opts);
+  if (opts.step && !isWorkflowRun(run)) {
+    throw new Error("Agent runs do not have workflow steps. Use `eigenpal runs get <run-id> --json` to inspect the agent run payload.");
+  }
+  if (isWorkflowRun(run)) {
+    const steps = filterWorkflowSteps(run.stepExecutions, opts.step);
+    const projectionIncludes = workflowStepProjectionIncludes(opts.include);
+    if (opts.step) {
+      return printJson({
+        ...payload,
+        run: { ...run, stepExecutions: projectWorkflowSteps(steps, projectionIncludes) }
+      });
+    }
+    if (opts.json) {
+      return printJson(payload);
+    }
+    console.log(renderFrame(toExecutionSnapshot(run, executionId)));
+    process.stderr.write(`${ui.dim(`use --json for the full payload, then pipe to jq for field projection`)}
+`);
+    return;
+  }
+  renderRunPayload(payload, opts);
+}
+function isWorkflowRun(run) {
+  return Array.isArray(run.stepExecutions);
+}
+function isAgentRun(run) {
+  return run.type === "agent";
+}
+function ensureAgentRun(run, feature) {
+  if (isAgentRun(run))
+    return;
+  throw new Error(`${feature} is only available for agent runs. Workflow runs do not have agent artifacts, feedback, or expected files.`);
+}
+async function getRunForCompatibilityCheck(client, executionId) {
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include: "detail"
+  });
+  if (!payload.run)
+    throw new Error(`Run ${executionId} not found`);
+  return payload.run;
+}
+async function ensureAgentRunById(client, executionId, feature) {
+  ensureAgentRun(await getRunForCompatibilityCheck(client, executionId), feature);
+}
+function workflowSteps(value) {
+  return Array.isArray(value) ? value : [];
+}
+function filterWorkflowSteps(value, stepFilter) {
+  const steps = workflowSteps(value);
+  if (!stepFilter)
+    return steps;
+  const wanted = new Set(stepFilter.split(",").map((step) => step.trim()).filter(Boolean));
+  return steps.filter((step) => typeof step.stepName === "string" && wanted.has(step.stepName));
+}
+function projectWorkflowSteps(steps, includes) {
+  return steps.map((step) => projectWorkflowStep(step, includes));
+}
+function workflowStepProjectionIncludes(includes) {
+  if (!includes)
+    return;
+  const parts = new Set(includes.split(",").map((part) => part.trim()));
+  const workflowFields = [
+    "input",
+    "config",
+    "resolvedConfig",
+    "inputRef",
+    "inputData",
+    "output",
+    "outputData",
+    "error",
+    "duration"
+  ];
+  return workflowFields.some((field) => parts.has(field)) ? includes : undefined;
+}
+function projectWorkflowStep(step, includes) {
+  if (!includes)
+    return step;
+  const wanted = new Set(includes.split(",").map((part) => part.trim()));
+  const out = { stepName: step.stepName, status: step.status };
+  if (wanted.has("input") || wanted.has("config") || wanted.has("resolvedConfig")) {
+    out.input = step.resolvedConfig;
+  }
+  if (wanted.has("inputRef") || wanted.has("inputData"))
+    out.inputRef = step.inputData;
+  if (wanted.has("output") || wanted.has("outputData"))
+    out.output = step.outputData;
+  if (wanted.has("error"))
+    out.error = step.error;
+  if (wanted.has("duration"))
+    out.durationMs = step.durationMs;
+  if ("overrideMode" in step)
+    out.overrideMode = step.overrideMode;
+  return out;
+}
+function toExecutionSnapshot(run, fallbackId) {
+  return {
+    id: String(run.id ?? run.executionId ?? fallbackId),
+    status: String(run.status ?? "unknown"),
+    startedAt: typeof run.startedAt === "string" ? run.startedAt : null,
+    completedAt: typeof run.completedAt === "string" ? run.completedAt : null,
+    durationMs: typeof run.durationMs === "number" ? run.durationMs : null,
+    stepExecutions: workflowSteps(run.stepExecutions).map((step) => ({
+      stepName: String(step.stepName ?? ""),
+      status: String(step.status ?? "unknown"),
+      durationMs: typeof step.durationMs === "number" ? step.durationMs : null,
+      error: typeof step.error === "string" ? step.error : null,
+      outputPreview: previewOutput(step.outputData)
+    })),
+    error: typeof run.error === "string" ? run.error : null
+  };
+}
+var PREVIEW_MAX = 120;
+function previewOutput(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "string") {
+    if (value.length === 0)
+      return null;
+    return value.length > PREVIEW_MAX ? `${value.slice(0, PREVIEW_MAX - 3)}...` : value;
+  }
+  let json2;
+  try {
+    json2 = JSON.stringify(value);
+  } catch {
+    return null;
+  }
+  if (!json2 || json2 === "{}" || json2 === "[]" || json2 === "null")
+    return null;
+  const flat = json2.replace(/\s+/g, " ");
+  return flat.length > PREVIEW_MAX ? `${flat.slice(0, PREVIEW_MAX - 3)}...` : flat;
+}
+async function rerunRun(executionId, opts) {
+  const client = buildClient(opts);
+  const sourceRef = await resolveRerunSourceRef(client, executionId, opts.sourceRef);
+  let payload = await client.post(`/api/v1/runs/${encodeURIComponent(executionId)}/rerun`, sourceRef ? { sourceRef } : {});
+  const rerunId = String(payload.runId ?? payload.executionId ?? "");
+  if (opts.wait && rerunId) {
+    payload = await pollRun(client, rerunId, opts.interval, opts.maxWait);
+    renderRunPayload(payload, opts);
+    setExitCodeForFailedTerminalRun(payload);
+    return;
+  }
+  if (opts.json)
+    return printJson(payload);
+  success2(`Started rerun ${ui.bold(rerunId)} from ${executionId}`);
+}
+async function resolveRerunSourceRef(client, executionId, requested) {
+  if (!requested)
+    return;
+  if (requested !== "original")
+    return requested;
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include: "detail"
+  });
+  const run = payload.run;
+  if (!run)
+    throw new Error(`Run ${executionId} not found`);
+  const resolved = stringOrNull(run.resolvedGitRef);
+  const requestedSource = stringOrNull(run.requestedSourceRef);
+  const original = resolved ?? requestedSource;
+  if (!original) {
+    throw new Error(`Run ${executionId} does not have an original source ref to reuse`);
+  }
+  return original;
+}
+async function fetchRunArtifacts(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include: "detail,expected,files,input,output,issues,trace,lockfile,metadata"
+  });
+  const run = payload.run;
+  if (!run)
+    throw new Error(`Run ${executionId} not found`);
+  ensureAgentRun(run, "Artifact download");
+  const out = path8.resolve(opts.out ?? path8.join(".eigenpal", "artifacts", "runs", executionId));
+  await fs3.mkdir(out, { recursive: true });
+  const written = [];
+  const skipped = [];
+  const selectedPaths = opts.path && opts.path.length > 0 ? opts.path : runArtifactInventory(run).filter((artifact) => artifactIncluded(artifact, opts.include)).map((artifact) => artifact.path);
+  for (const artifactPath of selectedPaths) {
+    const normalized = normalizeArtifactPath(artifactPath);
+    if (!normalized) {
+      skipped.push(artifactPath);
+      continue;
+    }
+    const result = await writeRunArtifact(client, executionId, out, normalized, run);
+    if (result)
+      written.push(result);
+    else
+      skipped.push(normalized);
+  }
+  const summary = {
+    runId: executionId,
+    out,
+    written,
+    skipped,
+    counts: {
+      written: written.length,
+      skipped: skipped.length
+    }
+  };
+  if (opts.json)
+    return printJson(summary);
+  success2(`Fetched run artifacts for ${executionId} to ${out}`);
+  dim(`Wrote ${written.length} artifact${written.length === 1 ? "" : "s"}${skipped.length ? `; skipped missing ${skipped.join(", ")}` : ""}`);
+}
+async function listRunArtifacts(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include: "detail,expected,files,input,output,issues,trace,lockfile,metadata"
+  });
+  const run = payload.run;
+  if (!run)
+    throw new Error(`Run ${executionId} not found`);
+  ensureAgentRun(run, "Artifact inventory");
+  const artifacts = runArtifactInventory(run);
+  if (opts.json)
+    return printJson({ runId: executionId, artifacts });
+  console.log(table(artifacts, [
+    { key: "kind", header: "KIND" },
+    { key: "name", header: "NAME" },
+    { key: "path", header: "PATH" },
+    { key: "present", header: "PRESENT" }
+  ]));
+}
+function artifactIncluded(artifact, include) {
+  const parts = new Set(include.split(",").map((part) => part.trim()).filter(Boolean));
+  if (parts.has("all"))
+    return true;
+  if (parts.has(artifact.kind))
+    return true;
+  if (parts.has("files") && (artifact.kind === "input" || artifact.kind === "output"))
+    return true;
+  if (parts.has("metadata") && artifact.path === "run.json")
+    return true;
+  return false;
+}
+function normalizeArtifactPath(artifactPath) {
+  const parts = artifactPath.split("/");
+  if (artifactPath.startsWith("/") || parts.some((part) => part === "" || part === "." || part === "..")) {
+    return null;
+  }
+  return artifactPath;
+}
+async function writeJsonRunArtifact(out, artifactPath, value) {
+  await fs3.mkdir(path8.dirname(path8.join(out, artifactPath)), { recursive: true });
+  await fs3.writeFile(path8.join(out, artifactPath), JSON.stringify(value, null, 2));
+}
+async function writeDownloadedRunArtifact(client, executionId, out, artifactPath, routePrefix) {
+  const routePath = routePrefix === "files" ? artifactPath : artifactPath.slice("expected/".length);
+  const routeBase = routePrefix === "files" ? "artifact" : "expected";
+  const response = await client.getStream(`/api/v1/runs/${encodeURIComponent(executionId)}/${routeBase}/${encodeRunArtifactPath(routePath)}`);
+  const outPath = path8.join(out, artifactPath);
+  await fs3.mkdir(path8.dirname(outPath), { recursive: true });
+  await fs3.writeFile(outPath, Buffer.from(await response.arrayBuffer()));
+}
+async function writeRunArtifact(client, executionId, out, artifactPath, run) {
+  if (artifactPath === "run.json") {
+    await writeJsonRunArtifact(out, artifactPath, run);
+    return artifactPath;
+  }
+  if (artifactPath === "input.json") {
+    if (run.inputJson == null)
+      return null;
+    await writeJsonRunArtifact(out, artifactPath, run.inputJson);
+    return artifactPath;
+  }
+  if (artifactPath === "metadata.json") {
+    if (run.metadata == null)
+      return null;
+    await writeJsonRunArtifact(out, artifactPath, run.metadata);
+    return artifactPath;
+  }
+  if (artifactPath === "expected.json") {
+    if (run.expected == null)
+      return null;
+    await writeJsonRunArtifact(out, artifactPath, run.expected);
+    return artifactPath;
+  }
+  if (artifactPath.startsWith("expected/")) {
+    await writeDownloadedRunArtifact(client, executionId, out, artifactPath, "expected");
+    return artifactPath;
+  }
+  await writeDownloadedRunArtifact(client, executionId, out, artifactPath, "files");
+  return artifactPath;
+}
+async function traceRun(executionId, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Trace download");
+  const text = await downloadTraceText(client, executionId);
+  if (!opts.out) {
+    process.stdout.write(text);
+    return;
+  }
+  const out = path8.resolve(opts.out);
+  await fs3.mkdir(path8.dirname(out), { recursive: true });
+  await fs3.writeFile(out, text);
+  success2(`Downloaded trace for ${executionId} to ${ui.bold(out)}`);
+}
+async function compareRun(referenceId, executionId, opts) {
+  const client = buildClient(opts);
+  const targetPayload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+    include: "detail,files,output"
+  });
+  const target = targetPayload.run;
+  if (!target)
+    throw new Error(`Run ${executionId} not found`);
+  const mode = opts.baseline ? "baseline" : "expected";
+  const reference = (await client.get(`/api/v1/runs/${encodeURIComponent(referenceId)}`, {
+    include: mode === "baseline" ? "detail,files,output" : "detail,expected"
+  })).run;
+  if (!reference)
+    throw new Error(`Reference run ${referenceId} not found`);
+  if (isWorkflowRun(reference) && isWorkflowRun(target)) {
+    const report2 = compareWorkflowRuns(referenceId, reference, executionId, target, opts.step);
+    if (opts.json) {
+      printJson(report2);
+    } else {
+      renderWorkflowComparisonReport(report2);
+    }
+    if (opts.failOnDiff && report2.status === "fail")
+      process.exit(1);
+    return;
+  }
+  if (opts.step) {
+    throw new Error("`--step` is only supported when both runs are workflow runs. Agent runs do not have workflow steps.");
+  }
+  if (isWorkflowRun(reference) || isWorkflowRun(target)) {
+    throw new Error("Mixed workflow/agent comparisons are not supported. Compare two workflow runs or two agent runs.");
+  }
+  const out = path8.resolve(opts.out ?? path8.join(".eigenpal", "artifacts", "comparisons", `${referenceId}..${executionId}`));
+  await fs3.mkdir(out, { recursive: true });
+  const warnings = [];
+  if (mode === "expected" && reference.expected == null && fileNames(reference.expectedFiles).length === 0) {
+    warnings.push(`Reference run ${referenceId} has no expected JSON or expected files; comparison has no baseline artifacts. Use --baseline to compare actual outputs.`);
+  }
+  const jsonDiffs = diffJson(mode === "baseline" ? reference.output : reference.expected, target.output);
+  const expectedFiles = mode === "baseline" ? fileNames(reference.resultFiles).filter((name) => name !== "issues.md" && name !== "trace.jsonl") : fileNames(reference.expectedFiles);
+  const outputFiles = fileNames(target.resultFiles).filter((name) => name !== "issues.md" && name !== "trace.jsonl");
+  const inventory = compareFileInventory(expectedFiles, outputFiles, Boolean(opts.normalizeDates));
+  const textDifferences = await compareMatchedFileText(client, { runId: referenceId, kind: mode === "baseline" ? "output" : "expected" }, { runId: executionId, kind: "output" }, out, inventory.matched, Boolean(opts.normalizeDates));
+  const report = {
+    status: jsonDiffs.length === 0 && inventory.missing.length === 0 && inventory.extra.length === 0 && textDifferences.every((diff) => diff.status === "match" || diff.status === "binary-match") ? "pass" : "fail",
+    runId: executionId,
+    comparedWithRunId: referenceId,
+    mode,
+    warnings,
+    jsonDifferences: jsonDiffs,
+    matchedFiles: inventory.matched,
+    missingFiles: inventory.missing,
+    extraFiles: inventory.extra,
+    textDifferences
+  };
+  await fs3.writeFile(path8.join(out, "comparison.json"), JSON.stringify(report, null, 2));
+  if (opts.json) {
+    printJson(report);
+  } else {
+    renderComparisonReport(report);
+  }
+  dim(`Comparison artifacts written to ${ui.bold(out)}`);
+  if (opts.failOnDiff && report.status === "fail")
+    process.exit(1);
+}
+function compareWorkflowRuns(referenceId, reference, targetId, target, stepFilter) {
+  const referenceSteps = workflowSteps(reference.stepExecutions);
+  const targetSteps = workflowSteps(target.stepExecutions);
+  const stepNames = new Set;
+  for (const step of referenceSteps)
+    if (step.stepName)
+      stepNames.add(step.stepName);
+  for (const step of targetSteps)
+    if (step.stepName)
+      stepNames.add(step.stepName);
+  const wanted = stepFilter ? new Set(stepFilter.split(",").map((step) => step.trim()).filter(Boolean)) : null;
+  const steps = [...stepNames].sort().filter((stepName) => !wanted || wanted.has(stepName)).map((stepName) => {
+    const referenceStep = referenceSteps.find((step) => step.stepName === stepName);
+    const targetStep = targetSteps.find((step) => step.stepName === stepName);
+    const referenceDuration = typeof referenceStep?.durationMs === "number" ? referenceStep.durationMs : null;
+    const targetDuration = typeof targetStep?.durationMs === "number" ? targetStep.durationMs : null;
+    return {
+      stepName,
+      referenceStatus: String(referenceStep?.status ?? "-"),
+      targetStatus: String(targetStep?.status ?? "-"),
+      durationDeltaMs: referenceDuration != null && targetDuration != null ? targetDuration - referenceDuration : null,
+      outputState: compareOutputs(referenceStep?.outputData, targetStep?.outputData)
+    };
+  });
+  const finalOutputState = compareOutputs(reference.output, target.output);
+  const status = finalOutputState === "identical" && steps.every((step) => step.referenceStatus === step.targetStatus && (step.outputState === "identical" || step.outputState === "-")) ? "pass" : "fail";
+  return {
+    status,
+    runId: targetId,
+    comparedWithRunId: referenceId,
+    steps,
+    finalOutputState
+  };
+}
+function renderWorkflowComparisonReport(report) {
+  console.log(`${ui.dim("A =")} ${ui.bold(report.comparedWithRunId)}   ${ui.dim("B =")} ${ui.bold(report.runId)}`);
+  console.log("");
+  console.log(ui.dim(`step                         A status    B status    Δ duration   output`));
+  console.log(ui.dim(`------------------------     ---------   ---------   ----------   ------`));
+  for (const step of report.steps) {
+    const delta = step.durationDeltaMs == null ? "-" : `${step.durationDeltaMs >= 0 ? "+" : ""}${step.durationDeltaMs}ms`;
+    console.log(`${step.stepName.padEnd(28)} ${padColored(colorStatus(step.referenceStatus), step.referenceStatus, 11)} ${padColored(colorStatus(step.targetStatus), step.targetStatus, 11)} ${delta.padEnd(12)} ${colorOutputState(step.outputState)}`);
+  }
+  console.log("");
+  console.log(`${ui.dim("final output:")} ${colorOutputState(report.finalOutputState)}`);
+}
+function padColored(colored, plain, width) {
+  const pad = Math.max(0, width - plain.length);
+  return colored + " ".repeat(pad);
+}
+function colorStatus(status) {
+  if (!status)
+    return "-";
+  if (status === "completed")
+    return ui.ok(status);
+  if (status === "failed" || status === "cancelled")
+    return ui.err(status);
+  if (status === "running" || status === "pending")
+    return ui.info(status);
+  return status;
+}
+function colorOutputState(state) {
+  if (state === "identical")
+    return ui.ok(state);
+  if (state === "-")
+    return ui.dim(state);
+  if (state.startsWith("differs"))
+    return ui.warn(state);
+  return state;
+}
+function compareOutputs(reference, target) {
+  if (reference === undefined && target === undefined)
+    return "-";
+  if (reference === undefined)
+    return "B only";
+  if (target === undefined)
+    return "A only";
+  const referenceJson = JSON.stringify(reference);
+  const targetJson = JSON.stringify(target);
+  if (referenceJson === targetJson)
+    return "identical";
+  return `differs (A=${referenceJson.length}b, B=${targetJson.length}b)`;
+}
+async function listRuns(source, opts) {
+  const client = buildClient(opts);
+  const parsedAgentTarget = source && (opts.type === "agent" || source.startsWith("agents.") || source.includes("@")) ? parseAgentTarget(source) : null;
+  const resolvedWorkflowSource = source && opts.type === "workflow" ? await resolveWorkflowId(client, source) : undefined;
+  const params = {
+    ...buildRunListParams(opts),
+    ...parsedAgentTarget ? { type: opts.type ?? "agent", source: parsedAgentTarget.slug } : resolvedWorkflowSource ? { source: resolvedWorkflowSource } : source ? { source } : {},
+    ...parsedAgentTarget?.sourceRef ? { sourceRef: parsedAgentTarget.sourceRef } : {}
+  };
+  const payload = await client.get("/api/v1/runs", params);
+  const rows = opts.compact ? payload.runs.map(compactRunRow) : payload.runs;
+  if (opts.json)
+    return printJson({ ...payload, runs: rows });
+  if (payload.scanLimited) {
+    warn("Feedback/expected filters scanned only the first matching window. Increase --scan-limit or narrow DB filters for a fuller result.");
+  }
+  if (payload.noResolvedAnchor) {
+    warn("No resolved feedback anchor was found in the scan window; --since-last-resolved returned no rows.");
+  }
+  console.log(table(rows, [
+    { key: "id", header: "ID" },
+    { key: "type", header: "TYPE" },
+    { key: "status", header: "STATUS" },
+    {
+      key: "sourceName",
+      header: "SOURCE",
+      format: (value, row) => String(value ?? row.sourceId ?? "")
+    },
+    { key: "exampleId", header: "EXAMPLE" },
+    {
+      key: "feedback",
+      header: "FEEDBACK",
+      format: (value) => value && typeof value === "object" ? `${String(value.rating ?? "")}/${String(value.status ?? "")}` : ""
+    },
+    { key: "createdAt", header: "CREATED", format: formatTimestamp }
+  ]));
+}
+function buildRunListParams(opts) {
+  return compactParams({
+    type: "type" in opts ? opts.type : undefined,
+    sourceRef: "sourceRef" in opts ? opts.sourceRef : undefined,
+    status: "status" in opts ? opts.status : undefined,
+    batchId: "batchId" in opts ? opts.batchId : undefined,
+    exampleId: "exampleId" in opts ? opts.exampleId : undefined,
+    exampleIdContains: "exampleIdContains" in opts ? opts.exampleIdContains : undefined,
+    from: "from" in opts ? opts.from : undefined,
+    to: "to" in opts ? opts.to : undefined,
+    createdAfter: "createdAfter" in opts ? opts.createdAfter : undefined,
+    createdBefore: "createdBefore" in opts ? opts.createdBefore : undefined,
+    completedAfter: "completedAfter" in opts ? opts.completedAfter : undefined,
+    completedBefore: "completedBefore" in opts ? opts.completedBefore : undefined,
+    limit: "limit" in opts ? opts.limit : undefined,
+    offset: "offset" in opts ? opts.offset : undefined,
+    sort: "sort" in opts ? opts.sort : undefined,
+    order: "order" in opts ? opts.order : undefined
+  });
+}
+async function updateRunFeedback(executionId, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Feedback");
+  const body = {};
+  if (opts.status)
+    body.status = opts.status;
+  if (opts.rating)
+    body.rating = opts.rating === "none" ? null : opts.rating;
+  if (opts.clearRating)
+    body.rating = null;
+  if (opts.messageFile)
+    body.body = await fs3.readFile(opts.messageFile, "utf-8");
+  if (opts.message !== undefined)
+    body.body = opts.message;
+  if (opts.clearMessage)
+    body.body = "";
+  if (opts.expectedJsonFile)
+    body.expected = JSON.parse(await fs3.readFile(opts.expectedJsonFile, "utf-8"));
+  if (opts.expectedJson !== undefined)
+    body.expected = JSON.parse(opts.expectedJson);
+  if (opts.clearExpectedJson)
+    body.expected = null;
+  const payload = await client.patch(`/api/v1/runs/${encodeURIComponent(executionId)}/feedback`, body);
+  renderGeneric(payload, opts, `Updated feedback for ${executionId}`);
+}
+function compactRunRow(run) {
+  const feedback = run.feedback && typeof run.feedback === "object" ? run.feedback : null;
+  return {
+    id: run.id,
+    status: run.status,
+    exampleId: run.exampleId,
+    feedback: feedback ? {
+      rating: feedback.rating ?? null,
+      status: feedback.status ?? null,
+      updatedAt: feedback.updatedAt ?? null
+    } : null,
+    hasExpectedJson: run.expected != null,
+    expectedFileCount: Array.isArray(run.expectedFiles) ? run.expectedFiles.length : undefined,
+    createdAt: run.createdAt,
+    completedAt: run.completedAt
+  };
+}
+async function clearRunFeedback(executionId, opts) {
+  if (!(opts.yes || await confirmTyped(executionId, "clear feedback artifacts"))) {
+    throw new Error("Clear cancelled");
+  }
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Feedback");
+  const payload = await client.delete(`/api/v1/runs/${encodeURIComponent(executionId)}/feedback`);
+  renderGeneric(payload, opts, `Cleared feedback for ${executionId}`);
+}
+async function listRunExpected(executionId, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}/expected`);
+  if (opts.json)
+    return printJson(payload);
+  console.log(table(payload.files ?? [], [{ key: "name", header: "NAME" }]));
+  if (payload.expected != null)
+    dim("expected.json present");
+}
+async function pullRunExpected(executionId, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}/expected`);
+  const out = path8.resolve(opts.out ?? path8.join(executionId, "expected"));
+  await fs3.mkdir(out, { recursive: true });
+  if (payload.expected != null) {
+    await fs3.writeFile(path8.join(out, "expected.json"), JSON.stringify(payload.expected, null, 2));
+  }
+  await downloadExpectedFiles(client, executionId, out, payload.files);
+  success2(`Pulled expected artifacts for ${executionId} to ${out}`);
+}
+async function downloadExpectedFiles(client, executionId, out, files) {
+  const rows = Array.isArray(files) ? files : [];
+  const written = await Promise.all(rows.map(async (file2) => {
+    const name = String(file2.name ?? "");
+    if (!name || name.includes("/") || name.includes(".."))
+      return null;
+    const response = await client.getStream(`/api/v1/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
+    await fs3.mkdir(out, { recursive: true });
+    await fs3.writeFile(path8.join(out, name), Buffer.from(await response.arrayBuffer()));
+    return name;
+  }));
+  return written.filter((name) => Boolean(name));
+}
+async function uploadRunExpected(executionId, file2, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  const form = new FormData;
+  const data = await fs3.readFile(file2);
+  form.append("file", new Blob([data]), path8.basename(file2));
+  if (opts.name)
+    form.append("name", opts.name);
+  const payload = await client.postFormData(`/api/v1/runs/${encodeURIComponent(executionId)}/expected`, form);
+  renderGeneric(payload, opts, `Uploaded expected file for ${executionId}`);
+}
+async function copyOutputToExpected(executionId, outputFile, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  const payload = await client.post(`/api/v1/runs/${encodeURIComponent(executionId)}/expected`, {
+    outputFileName: outputFile,
+    ...opts.name ? { expectedName: opts.name } : {}
+  });
+  renderGeneric(payload, opts, `Copied output file to expected for ${executionId}`);
+}
+async function renameRunExpected(executionId, oldName, newName, opts) {
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  const payload = await client.patch(`/api/v1/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(oldName)}`, { name: newName });
+  renderGeneric(payload, opts, `Renamed expected file for ${executionId}`);
+}
+async function deleteRunExpected(executionId, name, opts) {
+  if (!(opts.yes || await confirmTyped(name, "delete expected file"))) {
+    throw new Error("Delete cancelled");
+  }
+  const client = buildClient(opts);
+  await ensureAgentRunById(client, executionId, "Expected artifacts");
+  await client.delete(`/api/v1/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
+  renderGeneric({ ok: true }, opts, `Deleted expected file ${name}`);
+}
+async function watchRunCommand(executionId, opts) {
+  const client = buildClient(opts);
+  if (opts.json) {
+    const payload = await pollRun(client, executionId, opts.interval, opts.maxWait);
+    renderRunPayload(payload, opts);
+    setExitCodeForFailedTerminalRun(payload);
+    return;
+  }
+  const result = await watchExecution({
+    fetch: async () => {
+      const payload = await client.get(`/api/v1/runs/${encodeURIComponent(executionId)}`, {
+        include: "detail"
+      });
+      return toExecutionSnapshot(payload.run ?? {}, executionId);
+    },
+    maxMs: opts.maxWait * 1000,
+    transitionIntervalMs: opts.interval * 1000,
+    steadyIntervalMs: Math.max(opts.interval, 5) * 1000
+  });
+  if (result.detached) {
+    process.stderr.write(`
+Detached after ${opts.maxWait}s without reaching terminal status. Re-run \`eigenpal runs watch ${executionId}\` to resume.
+`);
+    process.exit(2);
+  }
+  if (result.final.status === "failed" || result.final.status === "cancelled") {
+    process.exitCode = 1;
+  }
+}
+async function cancelRun(executionId, opts) {
+  if (!(opts.yes || process.stdin.isTTY))
+    throw new Error("Pass --yes to cancel in non-interactive mode");
+  const client = buildClient(opts);
+  const payload = await client.post(`/api/v1/runs/${encodeURIComponent(executionId)}/cancel`, {});
+  renderRunPayload(payload, opts);
+}
+async function resumeRun(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.post(`/api/v1/runs/${encodeURIComponent(executionId)}/resume`, {});
+  renderRunPayload(payload, opts);
+}
+async function downloadTraceText(client, executionId) {
+  const response = await client.getStream(`/api/v1/runs/${encodeURIComponent(executionId)}/artifact/trace.jsonl`);
+  return Buffer.from(await response.arrayBuffer()).toString("utf-8");
+}
+function diffJson(expected, actual, basePath = "$") {
+  if (expected === undefined || expected === null)
+    return [];
+  if (Object.is(expected, actual))
+    return [];
+  if (expected && actual && typeof expected === "object" && typeof actual === "object" && !Array.isArray(expected) && !Array.isArray(actual)) {
+    const keys = new Set([...Object.keys(expected), ...Object.keys(actual)]);
+    return [...keys].flatMap((key) => {
+      const next = `${basePath}.${key}`;
+      if (!(key in actual))
+        return [{ path: next, type: "missing" }];
+      if (!(key in expected))
+        return [{ path: next, type: "extra" }];
+      return diffJson(expected[key], actual[key], next);
+    });
+  }
+  if (Array.isArray(expected) && Array.isArray(actual)) {
+    const diffs = [];
+    const max = Math.max(expected.length, actual.length);
+    for (let index = 0;index < max; index += 1) {
+      const next = `${basePath}[${index}]`;
+      if (index >= actual.length)
+        diffs.push({ path: next, type: "missing" });
+      else if (index >= expected.length)
+        diffs.push({ path: next, type: "extra" });
+      else
+        diffs.push(...diffJson(expected[index], actual[index], next));
+    }
+    return diffs;
+  }
+  return [
+    {
+      path: basePath,
+      type: "changed",
+      expected: JSON.stringify(expected),
+      actual: JSON.stringify(actual)
+    }
+  ];
+}
+function fileNames(files) {
+  return (Array.isArray(files) ? files : []).map((file2) => String(file2.name ?? "")).filter(Boolean).sort();
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function runArtifactInventory(run) {
+  const rows = [
+    { kind: "metadata", name: "run.json", path: "run.json", present: "yes" }
+  ];
+  if (run.inputJson != null) {
+    rows.push({ kind: "input", name: "input.json", path: "input.json", present: "yes" });
+  }
+  if (run.metadata != null) {
+    rows.push({ kind: "metadata", name: "metadata.json", path: "metadata.json", present: "yes" });
+  }
+  if (run.expected != null) {
+    rows.push({ kind: "expected", name: "expected.json", path: "expected.json", present: "yes" });
+  }
+  for (const name of fileNames(run.inputFiles)) {
+    rows.push({ kind: "input", name, path: `input/${name}`, present: "yes" });
+  }
+  for (const name of fileNames(run.resultFiles).filter((name2) => name2 !== "issues.md" && name2 !== "trace.jsonl")) {
+    rows.push({ kind: "output", name, path: `output/${name}`, present: "yes" });
+  }
+  for (const name of fileNames(run.expectedFiles)) {
+    rows.push({ kind: "expected", name, path: `expected/${name}`, present: "yes" });
+  }
+  for (const name of fileNames(run.issueFiles)) {
+    rows.push({ kind: "issues", name, path: name, present: "yes" });
+  }
+  for (const name of fileNames(run.traceFiles)) {
+    rows.push({ kind: "trace", name, path: name, present: "yes" });
+  }
+  for (const name of fileNames(run.lockfileFiles)) {
+    rows.push({ kind: "lockfile", name, path: name, present: "yes" });
+  }
+  return rows.sort((a, b2) => a.path.localeCompare(b2.path));
+}
+function normalizeGeneratedTokens(value) {
+  return value.replace(/\d{4}-\d{2}-\d{2}/g, "<date>").replace(/\d{8}/g, "<date>");
+}
+function compareFileInventory(expected, output, normalizeDates) {
+  const normalize = (value) => normalizeDates ? normalizeGeneratedTokens(value) : value;
+  const outputByNormalized = new Map(output.map((name) => [normalize(name), name]));
+  const expectedByNormalized = new Map(expected.map((name) => [normalize(name), name]));
+  const matched = expected.map((expectedName2) => {
+    const outputName = outputByNormalized.get(normalize(expectedName2));
+    return outputName ? { expected: expectedName2, output: outputName } : null;
+  }).filter((match) => Boolean(match));
+  return {
+    matched,
+    missing: expected.filter((name) => !outputByNormalized.has(normalize(name))),
+    extra: output.filter((name) => !expectedByNormalized.has(normalize(name)))
+  };
+}
+async function compareMatchedFileText(client, left, right, out, matched, normalizeDates) {
+  const expectedDir = path8.join(out, "expected");
+  const outputDir = path8.join(out, "output");
+  await fs3.mkdir(expectedDir, { recursive: true });
+  await fs3.mkdir(outputDir, { recursive: true });
+  const diffs = [];
+  for (const pair of matched) {
+    const expectedPath = path8.join(expectedDir, pair.expected);
+    const outputPath = path8.join(outputDir, pair.output);
+    await downloadStreamToFile(client, runFileUrl(left, pair.expected), expectedPath);
+    await downloadStreamToFile(client, runFileUrl(right, pair.output), outputPath);
+    const expectedText = extractComparableText(expectedPath);
+    const outputText = extractComparableText(outputPath);
+    if (expectedText.text == null || outputText.text == null) {
+      const [expectedBuffer, outputBuffer] = await Promise.all([
+        fs3.readFile(expectedPath),
+        fs3.readFile(outputPath)
+      ]);
+      const expectedHash = createHash2("sha256").update(expectedBuffer).digest("hex");
+      const outputHash = createHash2("sha256").update(outputBuffer).digest("hex");
+      diffs.push({
+        ...pair,
+        status: expectedBuffer.length === outputBuffer.length && expectedHash === outputHash ? "binary-match" : "binary-different",
+        expectedBytes: expectedBuffer.length,
+        outputBytes: outputBuffer.length,
+        expectedSha256: expectedHash,
+        outputSha256: outputHash,
+        textExtraction: {
+          expected: expectedText.reason ?? null,
+          output: outputText.reason ?? null
+        }
+      });
+      continue;
+    }
+    const normalize = (value) => normalizeDates ? normalizeGeneratedTokens(value).trim() : value.trim();
+    diffs.push({
+      ...pair,
+      status: normalize(expectedText.text) === normalize(outputText.text) ? "match" : "text-different"
+    });
+  }
+  return diffs;
+}
+function runFileUrl(side, name) {
+  const runId = encodeURIComponent(side.runId);
+  const filename = encodeURIComponent(name);
+  return side.kind === "expected" ? `/api/v1/runs/${runId}/expected/${filename}` : `/api/v1/runs/${runId}/artifact/output/${filename}`;
+}
+function encodeRunArtifactPath(artifactPath) {
+  return artifactPath.split("/").map(encodeURIComponent).join("/");
+}
+async function downloadStreamToFile(client, url2, target) {
+  await fs3.mkdir(path8.dirname(target), { recursive: true });
+  const response = await client.getStream(url2);
+  await fs3.writeFile(target, Buffer.from(await response.arrayBuffer()));
+}
+function extractComparableText(file2) {
+  const ext = path8.extname(file2).toLowerCase();
+  if ([".txt", ".md", ".json", ".csv", ".xml"].includes(ext)) {
+    return { text: readFileSync7(file2, "utf8") };
+  }
+  if (ext === ".pdf") {
+    const result = spawnSync4("pdftotext", [file2, "-"], { encoding: "utf8" });
+    return result.status === 0 ? { text: result.stdout } : { text: null, reason: textExtractionFallbackReason("pdftotext", result) };
+  }
+  if (ext === ".docx") {
+    const script = "import re,sys,zipfile; z=zipfile.ZipFile(sys.argv[1]); x=z.read('word/document.xml').decode('utf-8','ignore'); print(re.sub('<[^>]+>',' ',x))";
+    const result = spawnSync4("python3", ["-c", script, file2], { encoding: "utf8" });
+    return result.status === 0 ? { text: result.stdout } : { text: null, reason: textExtractionFallbackReason("python3", result) };
+  }
+  return { text: null, reason: `No text extractor for ${ext || "extensionless"} files` };
+}
+function textExtractionFallbackReason(tool, result) {
+  if (result.error)
+    return `${tool} unavailable; compared bytes instead`;
+  return `${tool} could not extract text; compared bytes instead`;
+}
+function renderComparisonReport(report) {
+  const header = `Comparison ${report.status}`;
+  if (report.status === "pass") {
+    success2(header);
+  } else {
+    error51(header);
+  }
+  for (const warning of report.warnings ?? []) {
+    dim(`warning: ${warning}`);
+  }
+  console.log(table([
+    { item: "JSON differences", count: report.jsonDifferences.length },
+    { item: "Matched files", count: report.matchedFiles.length },
+    { item: "Missing files", count: report.missingFiles.length },
+    { item: "Extra files", count: report.extraFiles.length },
+    {
+      item: "Text differences",
+      count: report.textDifferences.filter((diff) => diff.status === "text-different").length
+    }
+  ], [
+    { key: "item", header: "ITEM" },
+    { key: "count", header: "COUNT" }
+  ]));
+  for (const diff of report.textDifferences) {
+    const textExtraction = diff.textExtraction;
+    const reasons = [textExtraction?.expected, textExtraction?.output].filter((value) => typeof value === "string" && value.length > 0).filter((value, index, values) => values.indexOf(value) === index);
+    for (const reason of reasons) {
+      dim(`warning: ${String(diff.expected)} vs ${String(diff.output)}: ${reason}`);
+    }
+  }
+}
+
+// src/commands/agents/dataset.ts
+import path10 from "node:path";
+
 // src/commands/agents/validation.ts
 init_src();
 var import_yaml3 = __toESM(require_dist4(), 1);
-import { existsSync as existsSync7, promises as fs2 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync7, promises as fs4 } from "node:fs";
+import path9 from "node:path";
 async function validateAgentProject(root) {
   const errors3 = [];
   const warnings = [];
   for (const [oldName] of LEGACY_LAYOUTS) {
-    if (existsSync7(path7.join(root, oldName))) {
+    if (existsSync7(path9.join(root, oldName))) {
       errors3.push(`Legacy layout ${oldName}/ is removed; use Git source under agents/<slug>/`);
     }
   }
-  if (existsSync7(path7.join(root, "agent.yaml"))) {
+  if (existsSync7(path9.join(root, "agent.yaml"))) {
     errors3.push("Legacy agent.yaml layout is removed; use eigenpal.yaml in a Git-backed package");
   }
-  if (existsSync7(path7.join(root, "agent"))) {
+  if (existsSync7(path9.join(root, "agent"))) {
     errors3.push("Legacy agent/ directory is removed; use Git source (eigenpal agents clone)");
   }
-  const manifestPath = path7.join(root, PACKAGE_MANIFEST);
+  const manifestPath = path9.join(root, PACKAGE_MANIFEST);
   if (!existsSync7(manifestPath)) {
     errors3.push(`Missing ${PACKAGE_MANIFEST}`);
   } else {
     try {
-      SourcePackageManifestSchema.parse(import_yaml3.default.parse(await fs2.readFile(manifestPath, "utf8")));
+      SourcePackageManifestSchema.parse(import_yaml3.default.parse(await fs4.readFile(manifestPath, "utf8")));
     } catch (err) {
       errors3.push(err instanceof Error ? err.message : String(err));
     }
   }
-  if (!existsSync7(path7.join(root, "AGENT.md")))
+  if (!existsSync7(path9.join(root, "AGENT.md")))
     warnings.push("Missing AGENT.md");
-  if (!existsSync7(path7.join(root, DATASET_DIR)))
+  if (!existsSync7(path9.join(root, DATASET_DIR)))
     warnings.push(`Missing ${DATASET_DIR}/`);
   for (const filename of SCHEMA_FILENAMES) {
-    const schemaPath = path7.join(root, filename);
+    const schemaPath = path9.join(root, filename);
     if (!existsSync7(schemaPath))
       continue;
-    const validation2 = validateWorkspaceSchema(await fs2.readFile(schemaPath, "utf8"), filename);
+    const validation2 = validateWorkspaceSchema(await fs4.readFile(schemaPath, "utf8"), filename);
     for (const issue2 of validation2.errors) {
       errors3.push(`${filename}: ${issue2}`);
     }
@@ -191519,7 +192741,7 @@ async function validateDatasetDir(dir, opts = {}) {
   if (!existsSync7(dir))
     errors3.push(`Missing dataset directory: ${dir}`);
   for (const [oldName, newName] of LEGACY_LAYOUTS) {
-    if (path7.basename(dir) === oldName) {
+    if (path9.basename(dir) === oldName) {
       errors3.push(`Use ${newName}/ instead of legacy ${oldName}/`);
     }
   }
@@ -191530,28 +192752,28 @@ async function validateDatasetDir(dir, opts = {}) {
   const outputSchema = await loadOptionalWorkspaceSchema(agentDir, "output-schema.json", errors3);
   if (errors3.length > 0)
     return { valid: false, errors: errors3 };
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
   const examples = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   for (const example of examples) {
-    const exampleRoot = path7.join(dir, example);
+    const exampleRoot = path9.join(dir, example);
     if (inputSchema) {
       errors3.push(...await validateAgentDatasetInputExample(example, exampleRoot, inputSchema));
     } else {
-      await validateJsonObjectIfPresent(path7.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON), `${example}/${AGENT_EXAMPLE_INPUT_JSON}`, errors3);
+      await validateJsonObjectIfPresent(path9.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON), `${example}/${AGENT_EXAMPLE_INPUT_JSON}`, errors3);
     }
     if (outputSchema) {
       errors3.push(...await validateAgentDatasetExpectedExample(example, exampleRoot, outputSchema));
     } else {
-      await validateJsonObjectIfPresent(path7.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON), `${example}/${AGENT_EXAMPLE_EXPECTED_JSON}`, errors3);
+      await validateJsonObjectIfPresent(path9.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON), `${example}/${AGENT_EXAMPLE_EXPECTED_JSON}`, errors3);
     }
   }
   return { valid: errors3.length === 0, errors: errors3 };
 }
 async function loadOptionalWorkspaceSchema(agentDir, filename, errors3) {
-  const schemaPath = path7.join(agentDir, filename);
+  const schemaPath = path9.join(agentDir, filename);
   if (!existsSync7(schemaPath))
     return null;
-  const raw = await fs2.readFile(schemaPath, "utf8");
+  const raw = await fs4.readFile(schemaPath, "utf8");
   const validation2 = validateWorkspaceSchema(raw, filename);
   for (const issue2 of validation2.errors)
     errors3.push(`${filename}: ${issue2}`);
@@ -191586,8 +192808,8 @@ async function validateAgentDatasetInputExample(example, exampleRoot, inputSchem
   const errors3 = [];
   const props = schemaProperties(inputSchema);
   const required2 = schemaRequired(inputSchema);
-  const inputDir = path7.join(exampleRoot, "input");
-  const inputFiles = existsSync7(inputDir) ? (await fs2.readdir(inputDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
+  const inputDir = path9.join(exampleRoot, "input");
+  const inputFiles = existsSync7(inputDir) ? (await fs4.readdir(inputDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
   const matchedFiles = new Set;
   for (const [fieldName, propSchema] of Object.entries(props)) {
     if (!isFileField(propSchema))
@@ -191600,7 +192822,7 @@ async function validateAgentDatasetInputExample(example, exampleRoot, inputSchem
     }
   }
   const dataFields = Object.entries(props).filter(([, propSchema]) => !isFileField(propSchema)).map(([fieldName]) => fieldName);
-  const inputJsonPath = path7.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON);
+  const inputJsonPath = path9.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON);
   let inputData = null;
   if (existsSync7(inputJsonPath)) {
     inputData = await readJsonObject(inputJsonPath, `${example}/${AGENT_EXAMPLE_INPUT_JSON}`, errors3);
@@ -191640,9 +192862,9 @@ async function validateAgentDatasetInputExample(example, exampleRoot, inputSchem
 async function validateAgentDatasetExpectedExample(example, exampleRoot, outputSchema) {
   const errors3 = [];
   const props = schemaProperties(outputSchema);
-  const expectedPath = path7.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON);
-  const expectedDir = path7.join(exampleRoot, "expected");
-  const goldenFiles = existsSync7(expectedDir) ? (await fs2.readdir(expectedDir, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.name.startsWith(".")).map((entry) => entry.name) : [];
+  const expectedPath = path9.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON);
+  const expectedDir = path9.join(exampleRoot, "expected");
+  const goldenFiles = existsSync7(expectedDir) ? (await fs4.readdir(expectedDir, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.name.startsWith(".")).map((entry) => entry.name) : [];
   let expected = null;
   if (existsSync7(expectedPath)) {
     expected = await readJsonObject(expectedPath, `${example}/${AGENT_EXAMPLE_EXPECTED_JSON}`, errors3);
@@ -191690,7 +192912,7 @@ async function validateJsonObjectIfPresent(filePath, label, errors3) {
 }
 async function readJsonObject(filePath, label, errors3) {
   try {
-    const parsed = JSON.parse(await fs2.readFile(filePath, "utf8"));
+    const parsed = JSON.parse(await fs4.readFile(filePath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       errors3.push(`${label}: must be a JSON object`);
       return null;
@@ -191754,7 +192976,7 @@ async function pushDataset(agentId, opts) {
   if (opts.mode === "replace" && !(opts.yes || await confirmTyped(agentId, "replace dataset"))) {
     throw new Error("Dataset replace aborted");
   }
-  const files = await readFilesUnder(path8.resolve(opts.file));
+  const files = await readFilesUnder(path10.resolve(opts.file));
   const client = buildClient(opts);
   const payload = await client.post(`/api/v1/agents/${encodeURIComponent(agentId)}/dataset?mode=${opts.mode}`, { files });
   if (opts.json)
@@ -191766,15 +192988,15 @@ async function pullDataset(agentId, opts) {
   const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/dataset`, {
     include: "files"
   });
-  const out = path8.resolve(opts.out ?? DATASET_DIR);
+  const out = path10.resolve(opts.out ?? DATASET_DIR);
   for (const file2 of payload.files) {
-    await writeBase64File(path8.join(out, file2.path), file2.contentBase64);
+    await writeBase64File(path10.join(out, file2.path), file2.contentBase64);
   }
   success2(`Pulled dataset to ${ui.bold(out)}`);
 }
 async function validateDatasetCommand(dir = DATASET_DIR, opts) {
-  const result = await validateDatasetDir(path8.resolve(dir), {
-    agentDir: path8.resolve(opts.agentDir ?? ".")
+  const result = await validateDatasetDir(path10.resolve(dir), {
+    agentDir: path10.resolve(opts.agentDir ?? ".")
   });
   if (opts.json)
     return printJson(result);
@@ -191788,28 +193010,8 @@ async function validateDatasetCommand(dir = DATASET_DIR, opts) {
 // src/commands/agents/env.ts
 init_src();
 var import_yaml4 = __toESM(require_dist4(), 1);
-import { existsSync as existsSync8, promises as fs3, readFileSync as readFileSync7 } from "node:fs";
-import path9 from "node:path";
-
-// src/commands/agents/target.ts
-init_src();
-function parseAgentTarget(target) {
-  const [rawTarget, rawRef, extra] = target.split("@");
-  if (extra !== undefined)
-    throw new Error("Agent target must be <slug>[@ref].");
-  const normalizedTarget = rawTarget.includes(".") ? target : `agents.${rawTarget}${rawRef !== undefined ? `@${rawRef}` : ""}`;
-  const parsed = parseAutomationTarget(normalizedTarget);
-  if (parsed.type !== "agents") {
-    throw new Error("Only agent targets are supported in this release. Use agents.<slug>[@ref].");
-  }
-  return {
-    packageName: parsed.packageName,
-    slug: parsed.slug,
-    sourceRef: rawRef !== undefined ? parsed.ref : undefined
-  };
-}
-
-// src/commands/agents/env.ts
+import { existsSync as existsSync8, promises as fs5, readFileSync as readFileSync8 } from "node:fs";
+import path11 from "node:path";
 function registerEnvCommands(agent) {
   const env2 = agent.command("env").description("Export encrypted source secrets for a local installed agent package.").action(() => {
     process.stderr.write("`eigenpal agents env` requires a subcommand. Run `eigenpal agents env --help`.\n");
@@ -191830,7 +193032,7 @@ async function pullAgentEnv(target, opts) {
     throw new Error("--format must be shell or dotenv");
   }
   const client = buildClient(opts);
-  const requests = target ? await collectEncryptedSecretsForTarget(client, target) : await collectEncryptedSecrets(path9.resolve(opts.dir ?? "."));
+  const requests = target ? await collectEncryptedSecretsForTarget(client, target) : await collectEncryptedSecrets(path11.resolve(opts.dir ?? "."));
   if (requests.length === 0)
     return;
   const payload = await client.post("/api/v1/source/secrets/decrypt", {
@@ -191893,14 +193095,14 @@ async function readOptionalSourceFile(client, query) {
   }
 }
 async function collectEncryptedSecrets(root) {
-  const roots = [root, ...await listModulePackageRoots(path9.join(root, "eigenpal_modules"))];
+  const roots = [root, ...await listModulePackageRoots(path11.join(root, "eigenpal_modules"))];
   const seen = new Set;
   const requests = [];
   for (const packageRoot of roots) {
-    const secretsPath = path9.join(packageRoot, SOURCE_SECRETS_FILENAME);
+    const secretsPath = path11.join(packageRoot, SOURCE_SECRETS_FILENAME);
     if (!existsSync8(secretsPath))
       continue;
-    const parsed = SourceSecretsFileSchema.parse(import_yaml4.default.parse(await fs3.readFile(secretsPath, "utf8")));
+    const parsed = SourceSecretsFileSchema.parse(import_yaml4.default.parse(await fs5.readFile(secretsPath, "utf8")));
     const sourcePath = sourcePathForInstalledPackage(root, packageRoot);
     for (const [secretName, entry] of Object.entries(parsed.secrets)) {
       if (!entry.encrypted)
@@ -191923,14 +193125,14 @@ async function listModulePackageRoots(modulesRoot) {
   if (!existsSync8(modulesRoot))
     return [];
   const result = [];
-  for (const type of await fs3.readdir(modulesRoot)) {
-    const typeRoot = path9.join(modulesRoot, type);
-    const typeStat = await fs3.stat(typeRoot).catch(() => null);
+  for (const type of await fs5.readdir(modulesRoot)) {
+    const typeRoot = path11.join(modulesRoot, type);
+    const typeStat = await fs5.stat(typeRoot).catch(() => null);
     if (!typeStat?.isDirectory())
       continue;
-    for (const slug of await fs3.readdir(typeRoot)) {
-      const packageRoot = path9.join(typeRoot, slug);
-      const packageStat = await fs3.stat(packageRoot).catch(() => null);
+    for (const slug of await fs5.readdir(typeRoot)) {
+      const packageRoot = path11.join(typeRoot, slug);
+      const packageStat = await fs5.stat(packageRoot).catch(() => null);
       if (packageStat?.isDirectory())
         result.push(packageRoot);
     }
@@ -191938,16 +193140,16 @@ async function listModulePackageRoots(modulesRoot) {
   return result;
 }
 function sourcePathForInstalledPackage(root, packageRoot) {
-  const sourceRelative = path9.relative(root, packageRoot).replace(/\\/g, "/");
+  const sourceRelative = path11.relative(root, packageRoot).replace(/\\/g, "/");
   if (!sourceRelative.startsWith("..") && SourcePackagePathSchema.safeParse(sourceRelative).success) {
     return sourceRelative;
   }
-  const relative = path9.relative(path9.join(root, "eigenpal_modules"), packageRoot).replace(/\\/g, "/");
+  const relative = path11.relative(path11.join(root, "eigenpal_modules"), packageRoot).replace(/\\/g, "/");
   if (!relative.startsWith(".."))
     return relative;
-  const lockfilePath = path9.join(root, ".eigenpal", "eigenpal.lock");
+  const lockfilePath = path11.join(root, ".eigenpal", "eigenpal.lock");
   if (packageRoot === root && existsSync8(lockfilePath)) {
-    const lockfile = JSON.parse(readFileSync7(lockfilePath, "utf8"));
+    const lockfile = JSON.parse(readFileSync8(lockfilePath, "utf8"));
     if (typeof lockfile.root?.packagePath === "string")
       return lockfile.root.packagePath;
   }
@@ -191961,7 +193163,7 @@ function dotenvQuote(value) {
 }
 
 // src/commands/agents/experiments.ts
-import { promises as fs4 } from "node:fs";
+import { promises as fs6 } from "node:fs";
 function registerExperimentCommands(agent) {
   const experiment = agent.command("experiment").description("Run and inspect batches of agent executions.").action(() => {
     process.stderr.write("`eigenpal agents experiment` requires a subcommand. Run `eigenpal agents experiment --help`.\n");
@@ -192000,7 +193202,7 @@ async function experimentResults(agentId, batchId, opts) {
   const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/experiments/${encodeURIComponent(selected)}`);
   const content = opts.format === "json" ? JSON.stringify(payload, null, 2) : toCsv(payload.runs, ["id", "status", "exampleId"]);
   if (opts.out) {
-    await fs4.writeFile(opts.out, content);
+    await fs6.writeFile(opts.out, content);
     success2(`Wrote ${opts.out}`);
   } else {
     process.stdout.write(`${content}
@@ -192037,9 +193239,9 @@ async function cancelExperiment(agentId, batchId, opts) {
 }
 
 // src/commands/agents/files.ts
-import { createHash as createHash2 } from "node:crypto";
-import { promises as fs5 } from "node:fs";
-import path10 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { promises as fs7 } from "node:fs";
+import path12 from "node:path";
 function registerAgentFileCommands(agent) {
   const file2 = agent.command("file").description("List, download, and compare individual live agent files.").action(() => {
     process.stderr.write("`eigenpal agents file` requires a subcommand. Run `eigenpal agents file --help`.\n");
@@ -192065,19 +193267,19 @@ async function getAgentFile(agentId, remotePath, opts) {
   });
   if (opts.json)
     return printJson(payload);
-  const out = path10.resolve(opts.out ?? payload.path);
+  const out = path12.resolve(opts.out ?? payload.path);
   await writeBase64File(out, payload.contentBase64);
   success2(`Downloaded ${payload.path} to ${ui.bold(out)}`);
 }
 async function diffAgentFile(agentId, remotePath, localPath, opts) {
-  const report = await buildAgentFileDiff(agentId, remotePath, path10.resolve(localPath), opts);
+  const report = await buildAgentFileDiff(agentId, remotePath, path12.resolve(localPath), opts);
   if (opts.json)
     return printJson(report);
   renderAgentFileDiff(report);
 }
 async function buildAgentFileDiff(agentId, remotePath, localPath, opts) {
   const client = buildClient(opts);
-  const local = await fs5.readFile(localPath);
+  const local = await fs7.readFile(localPath);
   let remote = null;
   let serverPath = remotePath;
   try {
@@ -192090,8 +193292,8 @@ async function buildAgentFileDiff(agentId, remotePath, localPath, opts) {
     if (!(err instanceof ApiError) || err.status !== 404)
       throw err;
   }
-  const localHash = createHash2("sha256").update(local).digest("hex");
-  const remoteHash = remote ? createHash2("sha256").update(remote).digest("hex") : null;
+  const localHash = createHash3("sha256").update(local).digest("hex");
+  const remoteHash = remote ? createHash3("sha256").update(remote).digest("hex") : null;
   const status = !remote ? "remote-missing" : localHash === remoteHash ? "match" : "different";
   return {
     agentId,
@@ -192145,713 +193347,6 @@ function buildTextDiffPreview(remoteText, localText) {
   return preview;
 }
 
-// src/commands/agents/runs.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { promises as fs7, readFileSync as readFileSync8 } from "node:fs";
-import path12 from "node:path";
-
-// src/commands/agents/run-form-data.ts
-import { promises as fs6 } from "node:fs";
-import path11 from "node:path";
-async function buildAgentExecutionRunFormData(inputFile, inputJson) {
-  const form = new FormData;
-  for (const spec of parseAgentInputFileSpecs(inputFile)) {
-    const data = await fs6.readFile(spec.filePath);
-    form.append(spec.fieldName, new Blob([data]), path11.basename(spec.filePath));
-  }
-  if (inputJson)
-    form.append("_json", inputJson);
-  return form;
-}
-function parseAgentInputFileSpecs(inputFile) {
-  const values = Array.isArray(inputFile) ? inputFile : [inputFile];
-  return values.map((value) => {
-    const separatorIndex = value.indexOf("=");
-    if (separatorIndex === -1) {
-      return { fieldName: "file", filePath: value };
-    }
-    const fieldName = value.slice(0, separatorIndex).trim();
-    const filePath = value.slice(separatorIndex + 1).trim();
-    if (!fieldName || !filePath) {
-      throw new Error("--input-file must be <field=path> or a bare path");
-    }
-    if (fieldName === "_json" || fieldName === "_metadata" || fieldName === "input") {
-      throw new Error(`--input-file field "${fieldName}" is reserved`);
-    }
-    return { fieldName, filePath };
-  });
-}
-
-// src/commands/agents/runs.ts
-function registerRunCommands(agent) {
-  const runs = agent.command("runs").description("Inspect, watch, and manage agent runs.").action(() => {
-    process.stderr.write("`eigenpal agents runs` requires a subcommand. Run `eigenpal agents runs --help`.\n");
-    process.exit(2);
-  });
-  const listRunsCmd = addJsonFlag(withPagination(withBaseUrl(runs.command("list <target>")), 50)).description("List runs for an agent target; unqualified targets include all source refs.").option("--status <status>", "Filter by run status").option("--include <items>", "Comma-separated include list").option("--compact", "Render compact run rows").option("--sort <field>", "Sort field").option("--order <asc|desc>", "Sort order");
-  listRunsCmd.action(action(listRunsTarget));
-  addJsonFlag(withBaseUrl(runs.command("get <run-id>"))).description("Get one agent run.").option("--include <parts>", "Comma-separated extra parts: feedback,expected,files,trace,issues", "feedback").action(action(getRun));
-  addJsonFlag(withBaseUrl(runs.command("compare <reference-run-id> <run-id>"))).description("Compare one run against another run. PDF/DOCX text comparison uses pdftotext/python3 and reports byte fallbacks.").option("--baseline", "Compare actual outputs from both runs instead of expected artifacts").option("--out <dir>", "Write comparison artifacts to this directory").option("--normalize-dates", "Normalize YYYYMMDD and YYYY-MM-DD tokens in filenames/text").option("--fail-on-diff", "Exit 1 when comparison status is fail").action(action(compareRun));
-  const artifacts = runs.command("artifacts").description("Inspect run artifact inventory.").action(() => {
-    process.stderr.write("`eigenpal agents runs artifacts` requires a subcommand. Run `eigenpal agents runs artifacts --help`.\n");
-    process.exit(2);
-  });
-  addJsonFlag(withBaseUrl(artifacts.command("list <run-id>"))).description("List available run artifacts without downloading them.").action(action(listRunArtifacts));
-  withBaseUrl(artifacts.command("fetch <run-id>")).description("Download run artifacts by canonical artifact path.").option("--out <dir>", "Output directory").option("--include <parts>", "Comma-separated parts: output,input,metadata,issues,trace,lockfile,expected,all", "all").option("--path <path>", "Fetch one exact artifact path from `artifacts list`; repeatable", collectRepeated, []).option("--json", "Output a JSON summary of written artifacts").action(action(fetchRunArtifacts));
-  withBaseUrl(runs.command("trace <run-id>")).description("Print raw trace.jsonl for a run, or write it with --out.").option("--out <file>", "Output file path").action(action(traceRun));
-  registerRunFeedbackCommands(runs);
-  registerRunExpectedCommands(runs);
-  addJsonFlag(withBaseUrl(runs.command("watch <run-id>"))).description("Watch a run until it reaches a terminal status.").option("--interval <seconds>", "Polling interval in seconds", intArg, 2).option("--max-wait <seconds>", "Maximum wait before exiting 2", intArg, 1800).action(action(watchRunCommand));
-  addJsonFlag(withBaseUrl(runs.command("cancel <run-id>"))).description("Cancel an agent run.").option("--yes", "Required in non-interactive environments").action(action(cancelRun));
-}
-function registerRunFeedbackCommands(runs) {
-  const feedback = runs.command("feedback").description("Update or clear feedback attached to an agent run.").action(() => {
-    process.stderr.write("`eigenpal agents runs feedback` requires a subcommand. Run `eigenpal agents runs feedback --help`.\n");
-    process.exit(2);
-  });
-  addJsonFlag(withBaseUrl(feedback.command("update <run-id>"))).description("Edit feedback state, rating, message, or expected JSON for a run.").option("--status <open|resolved|ignored>", "Set feedback status").option("--rating <pass|fail|partial|none>", "Set feedback rating").option("--message <text>", "Set feedback message body").option("--message-file <path>", "Read feedback message body from a file").option("--expected-json <json>", "Set structured expected JSON").option("--expected-json-file <path>", "Read structured expected JSON from a file").option("--clear-message", "Clear the feedback message body").option("--clear-rating", "Clear feedback rating").option("--clear-expected-json", "Delete structured expected JSON").action(action(updateRunFeedback));
-  addJsonFlag(withBaseUrl(feedback.command("resolve <run-id>"))).description("Mark run feedback as resolved.").option("--message <text>", "Set feedback message body").option("--message-file <path>", "Read feedback message body from a file").action(action((runId, opts) => updateRunFeedback(runId, { ...opts, status: "resolved" })));
-  addJsonFlag(withBaseUrl(feedback.command("clear <run-id>"))).description("Delete feedback, expected.json, and expected files for a run.").option("--yes", "Required in non-interactive environments").action(action(clearRunFeedback));
-}
-function registerRunExpectedCommands(runs) {
-  const expected = runs.command("expected").description("Manage expected artifacts attached to an agent run.").action(() => {
-    process.stderr.write("`eigenpal agents runs expected` requires a subcommand. Run `eigenpal agents runs expected --help`.\n");
-    process.exit(2);
-  });
-  addJsonFlag(withBaseUrl(expected.command("list <run-id>"))).description("List expected JSON and files attached to a run.").action(action(listRunExpected));
-  withBaseUrl(expected.command("pull <run-id>")).description("Download expected JSON and files attached to a run.").option("--out <dir>", "Output directory").action(action(pullRunExpected));
-  addJsonFlag(withBaseUrl(expected.command("upload <run-id> <file>"))).description("Upload a local file as an expected artifact.").option("--name <name>", "Expected artifact name").action(action(uploadRunExpected));
-  addJsonFlag(withBaseUrl(expected.command("copy-output <run-id> <output-file>"))).description("Copy a generated output file into expected artifacts.").option("--name <name>", "Expected artifact name").action(action(copyOutputToExpected));
-  addJsonFlag(withBaseUrl(expected.command("rename <run-id> <old-name> <new-name>"))).description("Rename an expected artifact.").action(action(renameRunExpected));
-  addJsonFlag(withBaseUrl(expected.command("delete <run-id> <name>"))).description("Delete an expected artifact.").option("--yes", "Required in non-interactive environments").action(action(deleteRunExpected));
-}
-async function listRunsTarget(target, opts) {
-  const parsed = parseAgentTarget(target);
-  return listRuns(parsed.slug, { ...opts, sourceRef: parsed.sourceRef });
-}
-async function runExecution(agentId, opts) {
-  const client = buildClient(opts);
-  const runPath = `/api/v1/agents/${encodeURIComponent(agentId)}/run${opts.sourceRef ? `?sourceRef=${encodeURIComponent(opts.sourceRef)}` : ""}`;
-  let payload;
-  if (opts.inputFile && opts.inputFile.length > 0) {
-    const form = await buildAgentExecutionRunFormData(opts.inputFile, opts.inputJson);
-    payload = await client.postFormData(runPath, form);
-  } else {
-    payload = await client.post(runPath, {
-      input: opts.inputJson ? JSON.parse(opts.inputJson) : {},
-      ...opts.sourceRef ? { sourceRef: opts.sourceRef } : {}
-    });
-  }
-  const runId = String(payload.runId ?? "");
-  let waitedForTerminalRun = false;
-  if (opts.wait && runId) {
-    payload = await pollRun(client, runId, opts.interval ?? 2, opts.maxWait ?? 1800);
-    waitedForTerminalRun = true;
-  }
-  renderRunPayload(payload, opts);
-  if (waitedForTerminalRun)
-    setExitCodeForFailedTerminalRun(payload);
-}
-async function runExample(agentId, opts) {
-  const client = buildClient(opts);
-  const started = await client.post(`/api/v1/agents/${encodeURIComponent(agentId)}/experiments`, {
-    exampleId: opts.example,
-    ...opts.sourceRef ? { sourceRef: opts.sourceRef } : {}
-  });
-  const runId = started.runs?.[0]?.runId;
-  if (opts.wait && runId) {
-    const payload2 = await pollRun(client, runId, opts.interval, opts.maxWait);
-    renderRunPayload(payload2, opts);
-    setExitCodeForFailedTerminalRun(payload2);
-    return;
-  }
-  const payload = {
-    runId,
-    exampleId: opts.example,
-    batchId: started.batchId,
-    status: "pending"
-  };
-  if (opts.json)
-    return printJson(payload);
-  success2(`Run ${runId ?? ""} queued for example ${opts.example}`);
-}
-async function getRun(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`, {
-    ...opts.include ? { include: opts.include } : {}
-  });
-  renderRunPayload(payload, opts);
-}
-async function rerunRun(executionId, opts) {
-  const client = buildClient(opts);
-  const sourceRef = await resolveRerunSourceRef(client, executionId, opts.sourceRef);
-  let payload = await client.post(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/rerun`, sourceRef ? { sourceRef } : {});
-  const rerunId = String(payload.runId ?? "");
-  if (opts.wait && rerunId) {
-    payload = await pollRun(client, rerunId, opts.interval, opts.maxWait);
-    renderRunPayload(payload, opts);
-    setExitCodeForFailedTerminalRun(payload);
-    return;
-  }
-  if (opts.json)
-    return printJson(payload);
-  success2(`Started rerun ${ui.bold(rerunId)} from ${executionId}`);
-}
-async function resolveRerunSourceRef(client, executionId, requested) {
-  if (!requested)
-    return;
-  if (requested !== "original")
-    return requested;
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`);
-  const run = payload.run;
-  if (!run)
-    throw new Error(`Run ${executionId} not found`);
-  const resolved = stringOrNull(run.resolvedGitRef);
-  const requestedSource = stringOrNull(run.requestedSourceRef);
-  const original = resolved ?? requestedSource;
-  if (!original) {
-    throw new Error(`Run ${executionId} does not have an original source ref to reuse`);
-  }
-  return original;
-}
-async function fetchRunArtifacts(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`, {
-    include: "expected,files,input,output,issues,trace,lockfile,metadata"
-  });
-  const run = payload.run;
-  if (!run)
-    throw new Error(`Run ${executionId} not found`);
-  const out = path12.resolve(opts.out ?? path12.join(".eigenpal", "artifacts", "runs", executionId));
-  await fs7.mkdir(out, { recursive: true });
-  const written = [];
-  const skipped = [];
-  const selectedPaths = opts.path && opts.path.length > 0 ? opts.path : runArtifactInventory(run).filter((artifact) => artifactIncluded(artifact, opts.include)).map((artifact) => artifact.path);
-  for (const artifactPath of selectedPaths) {
-    const normalized = normalizeArtifactPath(artifactPath);
-    if (!normalized) {
-      skipped.push(artifactPath);
-      continue;
-    }
-    const result = await writeRunArtifact(client, executionId, out, normalized, run);
-    if (result)
-      written.push(result);
-    else
-      skipped.push(normalized);
-  }
-  const summary = {
-    runId: executionId,
-    out,
-    written,
-    skipped,
-    counts: {
-      written: written.length,
-      skipped: skipped.length
-    }
-  };
-  if (opts.json)
-    return printJson(summary);
-  success2(`Fetched run artifacts for ${executionId} to ${out}`);
-  dim(`Wrote ${written.length} artifact${written.length === 1 ? "" : "s"}${skipped.length ? `; skipped missing ${skipped.join(", ")}` : ""}`);
-}
-async function listRunArtifacts(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`, {
-    include: "expected,files,input,output,issues,trace,lockfile,metadata"
-  });
-  const run = payload.run;
-  if (!run)
-    throw new Error(`Run ${executionId} not found`);
-  const artifacts = runArtifactInventory(run);
-  if (opts.json)
-    return printJson({ runId: executionId, artifacts });
-  console.log(table(artifacts, [
-    { key: "kind", header: "KIND" },
-    { key: "name", header: "NAME" },
-    { key: "path", header: "PATH" },
-    { key: "present", header: "PRESENT" }
-  ]));
-}
-function artifactIncluded(artifact, include) {
-  const parts = new Set(include.split(",").map((part) => part.trim()).filter(Boolean));
-  if (parts.has("all"))
-    return true;
-  if (parts.has(artifact.kind))
-    return true;
-  if (parts.has("files") && (artifact.kind === "input" || artifact.kind === "output"))
-    return true;
-  if (parts.has("metadata") && artifact.path === "run.json")
-    return true;
-  return false;
-}
-function normalizeArtifactPath(artifactPath) {
-  const parts = artifactPath.split("/");
-  if (artifactPath.startsWith("/") || parts.some((part) => part === "" || part === "." || part === "..")) {
-    return null;
-  }
-  return artifactPath;
-}
-async function writeJsonRunArtifact(out, artifactPath, value) {
-  await fs7.mkdir(path12.dirname(path12.join(out, artifactPath)), { recursive: true });
-  await fs7.writeFile(path12.join(out, artifactPath), JSON.stringify(value, null, 2));
-}
-async function writeDownloadedRunArtifact(client, executionId, out, artifactPath, routePrefix) {
-  const routePath = routePrefix === "files" ? artifactPath : artifactPath.slice("expected/".length);
-  const response = await client.getStream(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/${routePrefix}/${encodeRunArtifactPath(routePath)}`);
-  const outPath = path12.join(out, artifactPath);
-  await fs7.mkdir(path12.dirname(outPath), { recursive: true });
-  await fs7.writeFile(outPath, Buffer.from(await response.arrayBuffer()));
-}
-async function writeRunArtifact(client, executionId, out, artifactPath, run) {
-  if (artifactPath === "run.json") {
-    await writeJsonRunArtifact(out, artifactPath, run);
-    return artifactPath;
-  }
-  if (artifactPath === "input.json") {
-    if (run.inputJson == null)
-      return null;
-    await writeJsonRunArtifact(out, artifactPath, run.inputJson);
-    return artifactPath;
-  }
-  if (artifactPath === "metadata.json") {
-    if (run.metadata == null)
-      return null;
-    await writeJsonRunArtifact(out, artifactPath, run.metadata);
-    return artifactPath;
-  }
-  if (artifactPath === "expected.json") {
-    if (run.expected == null)
-      return null;
-    await writeJsonRunArtifact(out, artifactPath, run.expected);
-    return artifactPath;
-  }
-  if (artifactPath.startsWith("expected/")) {
-    await writeDownloadedRunArtifact(client, executionId, out, artifactPath, "expected");
-    return artifactPath;
-  }
-  await writeDownloadedRunArtifact(client, executionId, out, artifactPath, "files");
-  return artifactPath;
-}
-async function traceRun(executionId, opts) {
-  const client = buildClient(opts);
-  const text = await downloadTraceText(client, executionId);
-  if (!opts.out) {
-    process.stdout.write(text);
-    return;
-  }
-  const out = path12.resolve(opts.out);
-  await fs7.mkdir(path12.dirname(out), { recursive: true });
-  await fs7.writeFile(out, text);
-  success2(`Downloaded trace for ${executionId} to ${ui.bold(out)}`);
-}
-async function compareRun(referenceId, executionId, opts) {
-  const client = buildClient(opts);
-  const targetPayload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}`, { include: "files,output" });
-  const target = targetPayload.run;
-  if (!target)
-    throw new Error(`Run ${executionId} not found`);
-  const mode = opts.baseline ? "baseline" : "expected";
-  const reference = (await client.get(`/api/v1/agents/runs/${encodeURIComponent(referenceId)}`, {
-    include: mode === "baseline" ? "files,output" : "expected"
-  })).run;
-  if (!reference)
-    throw new Error(`Reference run ${referenceId} not found`);
-  const out = path12.resolve(opts.out ?? path12.join(".eigenpal", "artifacts", "comparisons", `${referenceId}..${executionId}`));
-  await fs7.mkdir(out, { recursive: true });
-  const warnings = [];
-  if (mode === "expected" && reference.expected == null && fileNames(reference.expectedFiles).length === 0) {
-    warnings.push(`Reference run ${referenceId} has no expected JSON or expected files; comparison has no baseline artifacts. Use --baseline to compare actual outputs.`);
-  }
-  const jsonDiffs = diffJson(mode === "baseline" ? reference.output : reference.expected, target.output);
-  const expectedFiles = mode === "baseline" ? fileNames(reference.resultFiles).filter((name) => name !== "issues.md" && name !== "trace.jsonl") : fileNames(reference.expectedFiles);
-  const outputFiles = fileNames(target.resultFiles).filter((name) => name !== "issues.md" && name !== "trace.jsonl");
-  const inventory = compareFileInventory(expectedFiles, outputFiles, Boolean(opts.normalizeDates));
-  const textDifferences = await compareMatchedFileText(client, { runId: referenceId, kind: mode === "baseline" ? "output" : "expected" }, { runId: executionId, kind: "output" }, out, inventory.matched, Boolean(opts.normalizeDates));
-  const report = {
-    status: jsonDiffs.length === 0 && inventory.missing.length === 0 && inventory.extra.length === 0 && textDifferences.every((diff) => diff.status === "match" || diff.status === "binary-match") ? "pass" : "fail",
-    runId: executionId,
-    comparedWithRunId: referenceId,
-    mode,
-    warnings,
-    jsonDifferences: jsonDiffs,
-    matchedFiles: inventory.matched,
-    missingFiles: inventory.missing,
-    extraFiles: inventory.extra,
-    textDifferences
-  };
-  await fs7.writeFile(path12.join(out, "comparison.json"), JSON.stringify(report, null, 2));
-  if (opts.json) {
-    printJson(report);
-  } else {
-    renderComparisonReport(report);
-  }
-  dim(`Comparison artifacts written to ${ui.bold(out)}`);
-  if (opts.failOnDiff && report.status === "fail")
-    process.exit(1);
-}
-async function listRuns(agentId, opts) {
-  const client = buildClient(opts);
-  const params = buildRunListParams(opts);
-  const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/runs`, params);
-  const rows = opts.compact ? payload.runs.map(compactRunRow) : payload.runs;
-  if (opts.json)
-    return printJson({ ...payload, runs: rows });
-  if (payload.scanLimited) {
-    warn("Feedback/expected filters scanned only the first matching window. Increase --scan-limit or narrow DB filters for a fuller result.");
-  }
-  if (payload.noResolvedAnchor) {
-    warn("No resolved feedback anchor was found in the scan window; --since-last-resolved returned no rows.");
-  }
-  console.log(table(rows, [
-    { key: "id", header: "ID" },
-    { key: "status", header: "STATUS" },
-    { key: "exampleId", header: "EXAMPLE" },
-    {
-      key: "feedback",
-      header: "FEEDBACK",
-      format: (value) => value && typeof value === "object" ? `${String(value.rating ?? "")}/${String(value.status ?? "")}` : ""
-    },
-    { key: "createdAt", header: "CREATED", format: formatTimestamp }
-  ]));
-}
-function buildRunListParams(opts) {
-  return compactParams({
-    ...opts,
-    feedback: undefined,
-    noFeedback: opts.noFeedback ?? (opts.feedback === false ? true : undefined)
-  });
-}
-async function updateRunFeedback(executionId, opts) {
-  const client = buildClient(opts);
-  const body = {};
-  if (opts.status)
-    body.status = opts.status;
-  if (opts.rating)
-    body.rating = opts.rating === "none" ? null : opts.rating;
-  if (opts.clearRating)
-    body.rating = null;
-  if (opts.messageFile)
-    body.body = await fs7.readFile(opts.messageFile, "utf-8");
-  if (opts.message !== undefined)
-    body.body = opts.message;
-  if (opts.clearMessage)
-    body.body = "";
-  if (opts.expectedJsonFile)
-    body.expected = JSON.parse(await fs7.readFile(opts.expectedJsonFile, "utf-8"));
-  if (opts.expectedJson !== undefined)
-    body.expected = JSON.parse(opts.expectedJson);
-  if (opts.clearExpectedJson)
-    body.expected = null;
-  const payload = await client.patch(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/feedback`, body);
-  renderGeneric(payload, opts, `Updated feedback for ${executionId}`);
-}
-function compactRunRow(run) {
-  const feedback = run.feedback && typeof run.feedback === "object" ? run.feedback : null;
-  return {
-    id: run.id,
-    status: run.status,
-    exampleId: run.exampleId,
-    feedback: feedback ? {
-      rating: feedback.rating ?? null,
-      status: feedback.status ?? null,
-      updatedAt: feedback.updatedAt ?? null
-    } : null,
-    hasExpectedJson: run.expected != null,
-    expectedFileCount: Array.isArray(run.expectedFiles) ? run.expectedFiles.length : undefined,
-    createdAt: run.createdAt,
-    completedAt: run.completedAt
-  };
-}
-async function clearRunFeedback(executionId, opts) {
-  if (!(opts.yes || await confirmTyped(executionId, "clear feedback artifacts"))) {
-    throw new Error("Clear cancelled");
-  }
-  const client = buildClient(opts);
-  const payload = await client.delete(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/feedback`);
-  renderGeneric(payload, opts, `Cleared feedback for ${executionId}`);
-}
-async function listRunExpected(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected`);
-  if (opts.json)
-    return printJson(payload);
-  console.log(table(payload.files ?? [], [{ key: "name", header: "NAME" }]));
-  if (payload.expected != null)
-    dim("expected.json present");
-}
-async function pullRunExpected(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected`);
-  const out = path12.resolve(opts.out ?? path12.join(executionId, "expected"));
-  await fs7.mkdir(out, { recursive: true });
-  if (payload.expected != null) {
-    await fs7.writeFile(path12.join(out, "expected.json"), JSON.stringify(payload.expected, null, 2));
-  }
-  await downloadExpectedFiles(client, executionId, out, payload.files);
-  success2(`Pulled expected artifacts for ${executionId} to ${out}`);
-}
-async function downloadExpectedFiles(client, executionId, out, files) {
-  const rows = Array.isArray(files) ? files : [];
-  const written = await Promise.all(rows.map(async (file2) => {
-    const name = String(file2.name ?? "");
-    if (!name || name.includes("/") || name.includes(".."))
-      return null;
-    const response = await client.getStream(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
-    await fs7.mkdir(out, { recursive: true });
-    await fs7.writeFile(path12.join(out, name), Buffer.from(await response.arrayBuffer()));
-    return name;
-  }));
-  return written.filter((name) => Boolean(name));
-}
-async function uploadRunExpected(executionId, file2, opts) {
-  const client = buildClient(opts);
-  const form = new FormData;
-  const data = await fs7.readFile(file2);
-  form.append("file", new Blob([data]), path12.basename(file2));
-  if (opts.name)
-    form.append("name", opts.name);
-  const payload = await client.postFormData(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected`, form);
-  renderGeneric(payload, opts, `Uploaded expected file for ${executionId}`);
-}
-async function copyOutputToExpected(executionId, outputFile, opts) {
-  const client = buildClient(opts);
-  const payload = await client.post(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected`, { outputFileName: outputFile, ...opts.name ? { expectedName: opts.name } : {} });
-  renderGeneric(payload, opts, `Copied output file to expected for ${executionId}`);
-}
-async function renameRunExpected(executionId, oldName, newName, opts) {
-  const client = buildClient(opts);
-  const payload = await client.patch(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(oldName)}`, { name: newName });
-  renderGeneric(payload, opts, `Renamed expected file for ${executionId}`);
-}
-async function deleteRunExpected(executionId, name, opts) {
-  if (!(opts.yes || await confirmTyped(name, "delete expected file"))) {
-    throw new Error("Delete cancelled");
-  }
-  const client = buildClient(opts);
-  await client.delete(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
-  renderGeneric({ ok: true }, opts, `Deleted expected file ${name}`);
-}
-async function watchRunCommand(executionId, opts) {
-  const client = buildClient(opts);
-  const payload = await pollRun(client, executionId, opts.interval, opts.maxWait);
-  renderRunPayload(payload, opts);
-  setExitCodeForFailedTerminalRun(payload);
-}
-async function cancelRun(executionId, opts) {
-  if (!(opts.yes || process.stdin.isTTY))
-    throw new Error("Pass --yes to cancel in non-interactive mode");
-  const client = buildClient(opts);
-  const payload = await client.post(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/cancel`, {});
-  renderRunPayload(payload, opts);
-}
-async function downloadTraceText(client, executionId) {
-  const response = await client.getStream(`/api/v1/agents/runs/${encodeURIComponent(executionId)}/files/trace.jsonl`);
-  return Buffer.from(await response.arrayBuffer()).toString("utf-8");
-}
-function diffJson(expected, actual, basePath = "$") {
-  if (expected === undefined || expected === null)
-    return [];
-  if (Object.is(expected, actual))
-    return [];
-  if (expected && actual && typeof expected === "object" && typeof actual === "object" && !Array.isArray(expected) && !Array.isArray(actual)) {
-    const keys = new Set([...Object.keys(expected), ...Object.keys(actual)]);
-    return [...keys].flatMap((key) => {
-      const next = `${basePath}.${key}`;
-      if (!(key in actual))
-        return [{ path: next, type: "missing" }];
-      if (!(key in expected))
-        return [{ path: next, type: "extra" }];
-      return diffJson(expected[key], actual[key], next);
-    });
-  }
-  if (Array.isArray(expected) && Array.isArray(actual)) {
-    const diffs = [];
-    const max = Math.max(expected.length, actual.length);
-    for (let index = 0;index < max; index += 1) {
-      const next = `${basePath}[${index}]`;
-      if (index >= actual.length)
-        diffs.push({ path: next, type: "missing" });
-      else if (index >= expected.length)
-        diffs.push({ path: next, type: "extra" });
-      else
-        diffs.push(...diffJson(expected[index], actual[index], next));
-    }
-    return diffs;
-  }
-  return [
-    {
-      path: basePath,
-      type: "changed",
-      expected: JSON.stringify(expected),
-      actual: JSON.stringify(actual)
-    }
-  ];
-}
-function fileNames(files) {
-  return (Array.isArray(files) ? files : []).map((file2) => String(file2.name ?? "")).filter(Boolean).sort();
-}
-function stringOrNull(value) {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-function runArtifactInventory(run) {
-  const rows = [
-    { kind: "metadata", name: "run.json", path: "run.json", present: "yes" }
-  ];
-  if (run.inputJson != null) {
-    rows.push({ kind: "input", name: "input.json", path: "input.json", present: "yes" });
-  }
-  if (run.metadata != null) {
-    rows.push({ kind: "metadata", name: "metadata.json", path: "metadata.json", present: "yes" });
-  }
-  if (run.expected != null) {
-    rows.push({ kind: "expected", name: "expected.json", path: "expected.json", present: "yes" });
-  }
-  for (const name of fileNames(run.inputFiles)) {
-    rows.push({ kind: "input", name, path: `input/${name}`, present: "yes" });
-  }
-  for (const name of fileNames(run.resultFiles).filter((name2) => name2 !== "issues.md" && name2 !== "trace.jsonl")) {
-    rows.push({ kind: "output", name, path: `output/${name}`, present: "yes" });
-  }
-  for (const name of fileNames(run.expectedFiles)) {
-    rows.push({ kind: "expected", name, path: `expected/${name}`, present: "yes" });
-  }
-  for (const name of fileNames(run.issueFiles)) {
-    rows.push({ kind: "issues", name, path: name, present: "yes" });
-  }
-  for (const name of fileNames(run.traceFiles)) {
-    rows.push({ kind: "trace", name, path: name, present: "yes" });
-  }
-  for (const name of fileNames(run.lockfileFiles)) {
-    rows.push({ kind: "lockfile", name, path: name, present: "yes" });
-  }
-  return rows.sort((a, b2) => a.path.localeCompare(b2.path));
-}
-function normalizeGeneratedTokens(value) {
-  return value.replace(/\d{4}-\d{2}-\d{2}/g, "<date>").replace(/\d{8}/g, "<date>");
-}
-function compareFileInventory(expected, output, normalizeDates) {
-  const normalize = (value) => normalizeDates ? normalizeGeneratedTokens(value) : value;
-  const outputByNormalized = new Map(output.map((name) => [normalize(name), name]));
-  const expectedByNormalized = new Map(expected.map((name) => [normalize(name), name]));
-  const matched = expected.map((expectedName2) => {
-    const outputName = outputByNormalized.get(normalize(expectedName2));
-    return outputName ? { expected: expectedName2, output: outputName } : null;
-  }).filter((match) => Boolean(match));
-  return {
-    matched,
-    missing: expected.filter((name) => !outputByNormalized.has(normalize(name))),
-    extra: output.filter((name) => !expectedByNormalized.has(normalize(name)))
-  };
-}
-async function compareMatchedFileText(client, left, right, out, matched, normalizeDates) {
-  const expectedDir = path12.join(out, "expected");
-  const outputDir = path12.join(out, "output");
-  await fs7.mkdir(expectedDir, { recursive: true });
-  await fs7.mkdir(outputDir, { recursive: true });
-  const diffs = [];
-  for (const pair of matched) {
-    const expectedPath = path12.join(expectedDir, pair.expected);
-    const outputPath = path12.join(outputDir, pair.output);
-    await downloadStreamToFile(client, runFileUrl(left, pair.expected), expectedPath);
-    await downloadStreamToFile(client, runFileUrl(right, pair.output), outputPath);
-    const expectedText = extractComparableText(expectedPath);
-    const outputText = extractComparableText(outputPath);
-    if (expectedText.text == null || outputText.text == null) {
-      const [expectedBuffer, outputBuffer] = await Promise.all([
-        fs7.readFile(expectedPath),
-        fs7.readFile(outputPath)
-      ]);
-      const expectedHash = createHash3("sha256").update(expectedBuffer).digest("hex");
-      const outputHash = createHash3("sha256").update(outputBuffer).digest("hex");
-      diffs.push({
-        ...pair,
-        status: expectedBuffer.length === outputBuffer.length && expectedHash === outputHash ? "binary-match" : "binary-different",
-        expectedBytes: expectedBuffer.length,
-        outputBytes: outputBuffer.length,
-        expectedSha256: expectedHash,
-        outputSha256: outputHash,
-        textExtraction: {
-          expected: expectedText.reason ?? null,
-          output: outputText.reason ?? null
-        }
-      });
-      continue;
-    }
-    const normalize = (value) => normalizeDates ? normalizeGeneratedTokens(value).trim() : value.trim();
-    diffs.push({
-      ...pair,
-      status: normalize(expectedText.text) === normalize(outputText.text) ? "match" : "text-different"
-    });
-  }
-  return diffs;
-}
-function runFileUrl(side, name) {
-  const runId = encodeURIComponent(side.runId);
-  const filename = encodeURIComponent(name);
-  return side.kind === "expected" ? `/api/v1/agents/runs/${runId}/expected/${filename}` : `/api/v1/agents/runs/${runId}/files/output/${filename}`;
-}
-function encodeRunArtifactPath(artifactPath) {
-  return artifactPath.split("/").map(encodeURIComponent).join("/");
-}
-async function downloadStreamToFile(client, url2, target) {
-  await fs7.mkdir(path12.dirname(target), { recursive: true });
-  const response = await client.getStream(url2);
-  await fs7.writeFile(target, Buffer.from(await response.arrayBuffer()));
-}
-function extractComparableText(file2) {
-  const ext = path12.extname(file2).toLowerCase();
-  if ([".txt", ".md", ".json", ".csv", ".xml"].includes(ext)) {
-    return { text: readFileSync8(file2, "utf8") };
-  }
-  if (ext === ".pdf") {
-    const result = spawnSync4("pdftotext", [file2, "-"], { encoding: "utf8" });
-    return result.status === 0 ? { text: result.stdout } : { text: null, reason: textExtractionFallbackReason("pdftotext", result) };
-  }
-  if (ext === ".docx") {
-    const script = "import re,sys,zipfile; z=zipfile.ZipFile(sys.argv[1]); x=z.read('word/document.xml').decode('utf-8','ignore'); print(re.sub('<[^>]+>',' ',x))";
-    const result = spawnSync4("python3", ["-c", script, file2], { encoding: "utf8" });
-    return result.status === 0 ? { text: result.stdout } : { text: null, reason: textExtractionFallbackReason("python3", result) };
-  }
-  return { text: null, reason: `No text extractor for ${ext || "extensionless"} files` };
-}
-function textExtractionFallbackReason(tool, result) {
-  if (result.error)
-    return `${tool} unavailable; compared bytes instead`;
-  return `${tool} could not extract text; compared bytes instead`;
-}
-function renderComparisonReport(report) {
-  const header = `Comparison ${report.status}`;
-  if (report.status === "pass") {
-    success2(header);
-  } else {
-    error51(header);
-  }
-  for (const warning of report.warnings ?? []) {
-    dim(`warning: ${warning}`);
-  }
-  console.log(table([
-    { item: "JSON differences", count: report.jsonDifferences.length },
-    { item: "Matched files", count: report.matchedFiles.length },
-    { item: "Missing files", count: report.missingFiles.length },
-    { item: "Extra files", count: report.extraFiles.length },
-    {
-      item: "Text differences",
-      count: report.textDifferences.filter((diff) => diff.status === "text-different").length
-    }
-  ], [
-    { key: "item", header: "ITEM" },
-    { key: "count", header: "COUNT" }
-  ]));
-  for (const diff of report.textDifferences) {
-    const textExtraction = diff.textExtraction;
-    const reasons = [textExtraction?.expected, textExtraction?.output].filter((value) => typeof value === "string" && value.length > 0).filter((value, index, values) => values.indexOf(value) === index);
-    for (const reason of reasons) {
-      dim(`warning: ${String(diff.expected)} vs ${String(diff.output)}: ${reason}`);
-    }
-  }
-}
-
 // src/commands/agents/sessions.ts
 function registerSessionCommands(agent) {
   const session = agent.command("session").description("Manage agent builder sessions.").action(() => {
@@ -192900,18 +193395,16 @@ async function stopSession(sessionId, opts) {
 
 // src/commands/agents/index.ts
 function registerAgentCommands(program2) {
-  const agent = program2.command("agents").alias("agent").description("Manage Eigenpal agents: Git source, datasets, runs, experiments, sessions, and releases.").action(() => {
+  const agent = program2.command("agents").description("Manage Eigenpal agents: Git source, datasets, runs, experiments, sessions, and releases.").action(() => {
     process.stderr.write("`eigenpal agents` requires a subcommand. Run `eigenpal agents --help`.\n");
     process.exit(2);
   });
   addJsonFlag(withBaseUrl(agent.command("run <target>"))).description("Run an agent target, e.g. agents.invoice-agent@latest.").option("--input-json <json>", "JSON input object").option("--input-file <field=path>", 'Input file to upload as multipart form-data. Repeat for multiple files; bare paths use field "file".', collectRepeated, []).option("--example <name>", "Run a persisted dataset example by name").option("--wait", "Poll until the run reaches a terminal status").option("--interval <seconds>", "Polling interval in seconds", intArg, 2).option("--max-wait <seconds>", "Maximum wait before exiting 2", intArg, 1800).action(action(runTarget));
-  addJsonFlag(withBaseUrl(agent.command("rerun <run-id>"))).description("Create a new run from a previous run's stored input snapshot.").option("--source-ref <ref>", 'Source ref for the new run (default: latest). Use "original" to reproduce the previous resolved version.').option("--wait", "Poll until the rerun reaches a terminal status").option("--interval <seconds>", "Polling interval in seconds", intArg, 2).option("--max-wait <seconds>", "Maximum wait before exiting 2", intArg, 1800).action(action(rerunRun));
   addJsonFlag(withPagination(withBaseUrl(agent.command("list")), 50)).description("List agents.").option("--search <q>", "Search by slug, name, or description").action(action(listAgents));
   registerAgentFileCommands(agent);
   addJsonFlag(agent.command("validate [dir]")).description("Validate a local agent package (layout, manifest, schemas, and Git source rules).").action(action(validateAgentCommand));
   registerAgentSourceCommands(agent);
   registerDatasetCommands(agent);
-  registerRunCommands(agent);
   registerExperimentCommands(agent);
   registerSessionCommands(agent);
   registerEnvCommands(agent);
@@ -193487,7 +193980,7 @@ async function init(name, opts) {
   info("Next steps:");
   dim(`  cd ${targetDisplay}`);
   dim(`  eigenpal workflow validate                    # all three local checks`);
-  dim(`  eigenpal workflow execution run ${name} sample`);
+  dim(`  eigenpal workflow run ${name} sample`);
 }
 function assertSafeTargetDir(target, dir) {
   if (dir !== undefined && !dir.startsWith("/") && dir.split(/[/\\]/).some((s) => s === "..")) {
@@ -194858,80 +195351,6 @@ function formatEigenpalDirIfAvailable(dir) {
   });
 }
 
-// src/lib/resolve-workflow.ts
-var WORKFLOW_ID_PREFIX = "wf_";
-function looksLikeWorkflowId(value) {
-  return value.startsWith(WORKFLOW_ID_PREFIX);
-}
-function levenshtein(a, b2, maxDistance) {
-  if (a === b2)
-    return 0;
-  if (Math.abs(a.length - b2.length) > maxDistance)
-    return maxDistance + 1;
-  if (a.length === 0 || b2.length === 0)
-    return a.length || b2.length;
-  const prev = new Array(b2.length + 1);
-  const curr = new Array(b2.length + 1);
-  for (let j3 = 0;j3 <= b2.length; j3++)
-    prev[j3] = j3;
-  for (let i2 = 1;i2 <= a.length; i2++) {
-    curr[0] = i2;
-    let minRow = curr[0];
-    for (let j3 = 1;j3 <= b2.length; j3++) {
-      const cost = a[i2 - 1] === b2[j3 - 1] ? 0 : 1;
-      curr[j3] = Math.min(prev[j3] + 1, curr[j3 - 1] + 1, prev[j3 - 1] + cost);
-      if (curr[j3] < minRow)
-        minRow = curr[j3];
-    }
-    if (minRow > maxDistance)
-      return maxDistance + 1;
-    for (let j3 = 0;j3 <= b2.length; j3++)
-      prev[j3] = curr[j3];
-  }
-  return prev[b2.length];
-}
-async function findSimilarSlug(client, slug) {
-  try {
-    const res = await client.get("/api/v1/workflows", {
-      search: slug,
-      limit: "20"
-    });
-    const candidates = (res.data ?? []).map((w3) => w3.name).filter((n) => typeof n === "string" && n.length > 0);
-    let best = null;
-    for (const candidate of candidates) {
-      const distance = levenshtein(candidate, slug, 2);
-      if (distance <= 2 && (best === null || distance < best.distance)) {
-        best = { name: candidate, distance };
-      }
-    }
-    return best?.name ?? null;
-  } catch {
-    return null;
-  }
-}
-function notFound(idOrSlug, suggestion) {
-  const base = `Workflow "${idOrSlug}" not found on the server.`;
-  const action2 = "Push it first, or run `eigenpal workflow list` to see what's available.";
-  return new Error(suggestion ? `${base} Did you mean "${suggestion}"? ${action2}` : `${base} ${action2}`);
-}
-async function resolveWorkflowId(client, idOrSlug) {
-  if (looksLikeWorkflowId(idOrSlug)) {
-    try {
-      const wf = await client.get(`/api/v1/workflows/${idOrSlug}`);
-      return wf.id;
-    } catch {
-      throw notFound(idOrSlug, null);
-    }
-  }
-  const res = await client.get("/api/v1/workflows", { name: idOrSlug });
-  const match = res.data?.[0];
-  if (!match) {
-    const suggestion = await findSimilarSlug(client, idOrSlug);
-    throw notFound(idOrSlug, suggestion);
-  }
-  return match.id;
-}
-
 // src/commands/workflow/clear.ts
 import { existsSync as existsSync14, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync4 } from "fs";
 import { basename, join as join7 } from "path";
@@ -195225,125 +195644,6 @@ function registerEvaluatorTypeCommands(parent) {
   });
 }
 
-// src/lib/watch.ts
-var TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "rejected"]);
-var STATUS_BADGES = {
-  pending: "[ ]",
-  running: "[..]",
-  completed: "[ok]",
-  failed: "[x]",
-  cancelled: "[-]",
-  skipped: "[s]"
-};
-function statusBadge(status2) {
-  return STATUS_BADGES[status2] ?? `[${status2.slice(0, 3)}]`;
-}
-function durationSuffix(ms) {
-  const formatted = formatDuration(ms);
-  return formatted ? `  ${formatted}` : "";
-}
-function renderFrame(snapshot) {
-  const lines = [
-    `${statusBadge(snapshot.status)} ${snapshot.id}${durationSuffix(snapshot.durationMs)}`
-  ];
-  for (const step of snapshot.stepExecutions ?? []) {
-    const errSuffix = step.error ? `  err: ${step.error.slice(0, 80)}` : "";
-    lines.push(`  ${statusBadge(step.status)} ${step.stepName}${durationSuffix(step.durationMs)}${errSuffix}`);
-    if (step.outputPreview) {
-      lines.push(`     ↳ ${step.outputPreview}`);
-    }
-  }
-  if (snapshot.error && (snapshot.stepExecutions ?? []).length === 0) {
-    lines.push(`  err: ${snapshot.error.slice(0, 200)}`);
-  }
-  return lines.join(`
-`);
-}
-var ANSI_CURSOR_UP = "\x1B[A";
-var ANSI_CLEAR_LINE = "\x1B[2K\r";
-function makeAnsiRenderer() {
-  const isTty = Boolean(process.stderr.isTTY);
-  let previousLineCount = 0;
-  return (frame) => {
-    let buf = "";
-    if (isTty) {
-      for (let i2 = 0;i2 < previousLineCount; i2++) {
-        buf += i2 === 0 ? ANSI_CLEAR_LINE : `${ANSI_CURSOR_UP}${ANSI_CLEAR_LINE}`;
-      }
-    }
-    buf += frame;
-    if (!frame.endsWith(`
-`))
-      buf += `
-`;
-    if (!isTty && previousLineCount > 0)
-      buf += `
-`;
-    process.stderr.write(buf);
-    previousLineCount = frame.split(`
-`).length;
-  };
-}
-function defaultSleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
-}
-function snapshotsDiffer(a, b2) {
-  if (a.status !== b2.status)
-    return true;
-  const aSteps = a.stepExecutions ?? [];
-  const bSteps = b2.stepExecutions ?? [];
-  if (aSteps.length !== bSteps.length)
-    return true;
-  for (let i2 = 0;i2 < aSteps.length; i2++) {
-    if (aSteps[i2].stepName !== bSteps[i2].stepName || aSteps[i2].status !== bSteps[i2].status) {
-      return true;
-    }
-  }
-  return false;
-}
-function defaultShouldAbort(err2) {
-  return err2 instanceof ApiError && err2.status >= 400 && err2.status < 500;
-}
-async function watchExecution(opts) {
-  const sleep = opts.sleep ?? defaultSleep;
-  const now = opts.now ?? (() => Date.now());
-  const render = opts.render ?? makeAnsiRenderer();
-  const maxMs = opts.maxMs ?? 30 * 60 * 1000;
-  const transitionInterval = opts.transitionIntervalMs ?? 2000;
-  const steadyInterval = opts.steadyIntervalMs ?? 5000;
-  const shouldAbort = opts.shouldAbort ?? defaultShouldAbort;
-  const start = now();
-  let previous;
-  let lastFetched;
-  while (true) {
-    let current;
-    try {
-      current = await opts.fetch();
-    } catch (err2) {
-      if (shouldAbort(err2))
-        throw err2;
-      const message = err2 instanceof Error ? err2.message : String(err2);
-      render(`(network) ${message.slice(0, 120)}`);
-      if (lastFetched && now() - start >= maxMs) {
-        return { final: lastFetched, detached: true };
-      }
-      await sleep(steadyInterval);
-      continue;
-    }
-    lastFetched = current;
-    render(renderFrame(current));
-    if (TERMINAL_STATUSES.has(current.status)) {
-      return { final: current, detached: false };
-    }
-    if (now() - start >= maxMs) {
-      return { final: current, detached: true };
-    }
-    const transitioned = previous == null || snapshotsDiffer(previous, current);
-    previous = current;
-    await sleep(transitioned ? transitionInterval : steadyInterval);
-  }
-}
-
 // src/commands/workflow/exec.ts
 import { join as join11 } from "path";
 
@@ -195532,7 +195832,8 @@ var DEFAULT_CONCURRENCY = 3;
 async function pollExecution(client, executionId) {
   const start = Date.now();
   while (Date.now() - start < MAX_POLL_MS) {
-    const res = await client.get(`/api/v1/workflows/executions/${executionId}`);
+    const payload = await client.get(`/api/v1/runs/${executionId}?include=detail`);
+    const res = "run" in payload && payload.run ? payload.run : payload;
     if (["completed", "failed", "cancelled", "rejected"].includes(res.status))
       return res;
     await new Promise((r5) => setTimeout(r5, POLL_INTERVAL_MS));
@@ -195610,7 +195911,8 @@ async function runExec(client, dir, workflowIdOrSlug, exampleNames, options8 = {
         else
           failed++;
         try {
-          const artifact = await client.get(`/api/v1/workflows/executions/${executionId}?includeSteps=true`);
+          const artifactPayload = await client.get(`/api/v1/runs/${executionId}?include=detail`);
+          const artifact = "run" in artifactPayload && artifactPayload.run ? artifactPayload.run : artifactPayload;
           const artifactDir = await writeExecutionArtifacts(client, exampleDir, artifact);
           if (!interactive)
             console.log(ui.dim(`  Artifacts: ${artifactDir}`));
@@ -195637,14 +195939,13 @@ ${ui.bold("Results:")} ${ui.ok(String(passed))} passed, ${failed > 0 ? ui.err(St
 }
 
 // src/commands/workflow/execution.ts
-function registerWorkflowExecutionCommands(parent) {
-  const execution = parent.command("execution").description("Run, inspect, and compare server-side executions.");
-  const runCmd = execution.command("run <workflow-id> [examples...]").description("Run a saved workflow against local dataset examples.").option("--dir <dir>", "Local eigenpal directory", undefined).option("--concurrency <n>", "Max examples to run in parallel (default: 3)", intArg).addHelpText("after", `
+function registerWorkflowRunCommand(parent) {
+  const runCmd = parent.command("run <workflow-id> [examples...]").description("Run a saved workflow against local dataset examples.").option("--dir <dir>", "Local eigenpal directory", undefined).option("--concurrency <n>", "Max examples to run in parallel (default: 3)", intArg).addHelpText("after", `
 Examples:
-  $ eigenpal workflow execution run wf_abc123                  # all examples
-  $ eigenpal workflow execution run wf_abc123 sample-1 sample-2
-  $ eigenpal workflow execution run wf_abc123 --concurrency 5
-  $ eigenpal workflow execution run wf_abc123 sample --json | jq '.passed'
+  $ eigenpal workflow run wf_abc123                  # all examples
+  $ eigenpal workflow run wf_abc123 sample-1 sample-2
+  $ eigenpal workflow run wf_abc123 --concurrency 5
+  $ eigenpal workflow run wf_abc123 sample --json | jq '.passed'
 
 Reads examples from ./dataset/examples/<example>/ and writes per-run
 artifacts to ./dataset/examples/<example>/executions/<timestamp>/.
@@ -195671,272 +195972,6 @@ Exits 1 when any example fails.
       formatEigenpalDirIfAvailable(config2.dir);
     }
   });
-  const getCmd = execution.command("get <executionId>").description("Fetch a single execution payload. Optionally narrow to one step.").option("--step <name>", "Show only this step (or comma-separated list)").option("--include <kinds>", "Comma-separated subset of input,output,error,duration. `input` projects the resolved templated config (= what the processor actually received). `inputRef` returns the minimal predecessor-id reference instead.", "input,output,error,duration").addHelpText("after", "\nFor field projection, pipe `--json` through real jq:\n" + `  $ eigenpal workflow execution get exec_… --json | jq '.status'
-` + `  $ eigenpal workflow execution get exec_… --json | jq '.stepExecutions[] | select(.status=="failed")'
-`);
-  addJsonFlag(withBaseUrl(getCmd)).action(getExecution);
-  const listCmd = execution.command("list <workflow-id>").description("List recent executions for a workflow.").option("--status <status>", "Filter by status: pending|running|completed|failed|cancelled");
-  addJsonFlag(withBaseUrl(withPagination(listCmd))).action(listExecutions);
-  const watchCmd = execution.command("watch <executionId>").description("Stream live execution status until terminal or 30-min detach.").option("--max-wait <seconds>", "Detach after N seconds (default 1800 = 30 min)", intArg, 30 * 60);
-  withBaseUrl(watchCmd).action(watchCommand);
-  const compareCmd = execution.command("compare <executionA> <executionB>").description("Diff two executions side-by-side, per step.").option("--step <name>", "Restrict comparison to one step");
-  withBaseUrl(compareCmd).action(compareExecutions);
-  const cancelCmd = execution.command("cancel <executionId>").description("Cancel an execution. Idempotent on already-terminal runs.").option("--yes", "Required for non-TTY shells (CI, pipes). Acts immediately, no prompt.").addHelpText("after", `
-Examples:
-  $ eigenpal workflow execution cancel exec_123abc
-  $ eigenpal workflow execution cancel exec_123abc --yes        # required in CI
-  $ eigenpal workflow execution cancel exec_123abc --json       # raw server payload
-
-Behavior:
-  - created/pending: transitions straight to cancelled.
-  - running/waiting: stamps cancelRequestedAt; the worker observes it
-    between step transitions and exits cleanly.
-  - already terminal (completed/failed/cancelled): no-op, exits 0 with an
-    info line. Idempotent — safe to retry.
-`);
-  addJsonFlag(withBaseUrl(cancelCmd)).action(async (executionId, opts) => {
-    const config2 = resolveConfig(opts);
-    requireApiKey(config2);
-    const client = new ApiClient(config2);
-    try {
-      await cancelExecution(client, executionId, opts);
-    } catch (err2) {
-      error51(err2 instanceof Error ? err2.message : String(err2));
-      process.exit(1);
-    }
-  });
-}
-async function cancelExecution(client, executionId, opts) {
-  if (!opts.yes && !isTTY()) {
-    throw new Error("cancel is destructive and requires --yes when run non-interactively");
-  }
-  const result = await client.post(`/api/v1/workflows/executions/${executionId}/cancel`);
-  if (opts.json) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  const status2 = result.status;
-  if (status2 === "already-terminal") {
-    info(`already terminal: ${result.wasStatus ?? "unknown"}`);
-    return;
-  }
-  if (status2 === "cancelled" || status2 === "cancellation-requested") {
-    success2("cancellation requested");
-    return;
-  }
-  info(`server returned status: ${String(status2 ?? "unknown")}`);
-}
-async function getExecution(executionId, opts) {
-  const config2 = resolveConfig(opts);
-  requireApiKey(config2);
-  const client = new ApiClient(config2);
-  try {
-    const result = await client.get(`/api/v1/workflows/executions/${executionId}?includeSteps=true`);
-    if (opts.step) {
-      const wanted = new Set(opts.step.split(",").map((s5) => s5.trim()));
-      const filtered = (result.stepExecutions ?? []).filter((s5) => wanted.has(s5.stepName));
-      console.log(JSON.stringify({ stepExecutions: filtered.map((s5) => filterIncludes(s5, opts.include)) }, null, 2));
-      return;
-    }
-    if (opts.json) {
-      console.log(JSON.stringify({
-        ...result,
-        stepExecutions: (result.stepExecutions ?? []).map((s5) => filterIncludes(s5, opts.include))
-      }, null, 2));
-      return;
-    }
-    const snapshot = {
-      id: result.id ?? executionId,
-      status: result.status ?? "unknown",
-      startedAt: result.startedAt ?? null,
-      completedAt: result.completedAt ?? null,
-      durationMs: result.durationMs ?? null,
-      stepExecutions: (result.stepExecutions ?? []).map((s5) => ({
-        stepName: s5.stepName,
-        status: s5.status,
-        durationMs: s5.durationMs,
-        error: s5.error,
-        outputPreview: previewOutput(s5.outputData)
-      })),
-      error: result.error ?? null
-    };
-    console.log(renderFrame(snapshot));
-    process.stderr.write(`${ui.dim(`use --json for the full payload, then pipe to jq for field projection`)}
-`);
-  } catch (err2) {
-    error51(err2 instanceof Error ? err2.message : String(err2));
-    process.exit(1);
-  }
-}
-async function listExecutions(workflow2, opts) {
-  const config2 = resolveConfig(opts);
-  requireApiKey(config2);
-  const client = new ApiClient(config2);
-  const workflowId = await resolveWorkflowId(client, workflow2);
-  const params = {
-    limit: String(opts.limit),
-    offset: String(opts.offset),
-    workflowId
-  };
-  if (opts.status)
-    params.status = opts.status;
-  try {
-    const raw = await client.get(`/api/v1/workflows/${workflowId}/executions`, params);
-    renderListResult(raw, [
-      { key: "id", header: "id" },
-      { key: "status", header: "status" },
-      { key: "startedAt", header: "startedAt", format: formatTimestamp },
-      {
-        key: "durationMs",
-        header: "duration",
-        align: "right",
-        format: (v11) => typeof v11 === "number" ? formatDuration(v11) : "-"
-      }
-    ], { json: opts.json, entityLabel: "execution" });
-  } catch (err2) {
-    error51(err2 instanceof Error ? err2.message : String(err2));
-    process.exit(1);
-  }
-}
-async function watchCommand(executionId, opts) {
-  const config2 = resolveConfig(opts);
-  requireApiKey(config2);
-  const client = new ApiClient(config2);
-  try {
-    const result = await watchExecution({
-      fetch: () => client.get(`/api/v1/workflows/executions/${executionId}?includeSteps=true`),
-      maxMs: opts.maxWait * 1000
-    });
-    if (result.detached) {
-      process.stderr.write(`
-Detached after ${opts.maxWait}s without reaching terminal status. Re-run \`eigenpal workflow execution watch ${executionId}\` to resume.
-`);
-      process.exit(2);
-    }
-    if (result.final.status === "failed" || result.final.status === "cancelled") {
-      process.exit(1);
-    }
-  } catch (err2) {
-    error51(err2 instanceof Error ? err2.message : String(err2));
-    process.exit(1);
-  }
-}
-async function compareExecutions(idA, idB, opts) {
-  const config2 = resolveConfig(opts);
-  requireApiKey(config2);
-  const client = new ApiClient(config2);
-  try {
-    const [a5, b8] = await Promise.all([
-      client.get(`/api/v1/workflows/executions/${idA}?includeSteps=true`),
-      client.get(`/api/v1/workflows/executions/${idB}?includeSteps=true`)
-    ]);
-    const stepNames = new Set;
-    for (const s5 of a5.stepExecutions ?? [])
-      stepNames.add(s5.stepName);
-    for (const s5 of b8.stepExecutions ?? [])
-      stepNames.add(s5.stepName);
-    const ordered = Array.from(stepNames).sort();
-    const targetSteps = opts.step ? ordered.filter((n5) => n5 === opts.step) : ordered;
-    console.log(`${ui.dim("A =")} ${ui.bold(idA)}   ${ui.dim("status=")}${colorStatus(a5.status)}   ${ui.dim("durationMs=")}${a5.durationMs ?? "-"}`);
-    console.log(`${ui.dim("B =")} ${ui.bold(idB)}   ${ui.dim("status=")}${colorStatus(b8.status)}   ${ui.dim("durationMs=")}${b8.durationMs ?? "-"}`);
-    console.log("");
-    console.log(ui.dim(`step                         A status    B status    Δ duration   output`));
-    console.log(ui.dim(`────────────────────────     ─────────   ─────────   ──────────   ──────`));
-    for (const stepName of targetSteps) {
-      const aStep = (a5.stepExecutions ?? []).find((s5) => s5.stepName === stepName);
-      const bStep = (b8.stepExecutions ?? []).find((s5) => s5.stepName === stepName);
-      const aStatus = aStep?.status ?? "—";
-      const bStatus = bStep?.status ?? "—";
-      const aDur = aStep?.durationMs ?? null;
-      const bDur = bStep?.durationMs ?? null;
-      const delta = aDur != null && bDur != null ? `${bDur - aDur >= 0 ? "+" : ""}${bDur - aDur}ms` : "—";
-      const outputState = compareOutputs(aStep?.output, bStep?.output);
-      console.log(`${stepName.padEnd(28)} ${padColored(colorStatus(aStatus), aStatus, 11)} ${padColored(colorStatus(bStatus), bStatus, 11)} ${delta.padEnd(12)} ${colorOutputState(outputState)}`);
-    }
-    const finalState = compareOutputs(a5.output, b8.output);
-    console.log("");
-    console.log(`${ui.dim("final output:")} ${colorOutputState(finalState)}`);
-  } catch (err2) {
-    error51(err2 instanceof Error ? err2.message : String(err2));
-    process.exit(1);
-  }
-}
-function padColored(colored, plain, width) {
-  const pad = Math.max(0, width - plain.length);
-  return colored + " ".repeat(pad);
-}
-function colorStatus(status2) {
-  if (!status2)
-    return "—";
-  if (status2 === "completed")
-    return ui.ok(status2);
-  if (status2 === "failed" || status2 === "cancelled")
-    return ui.err(status2);
-  if (status2 === "running" || status2 === "pending")
-    return ui.info(status2);
-  return status2;
-}
-function colorOutputState(state) {
-  if (state === "identical")
-    return ui.ok(state);
-  if (state === "—")
-    return ui.dim(state);
-  if (state.startsWith("differs"))
-    return ui.warn(state);
-  return state;
-}
-function compareOutputs(a5, b8) {
-  if (a5 === undefined && b8 === undefined)
-    return "—";
-  if (a5 === undefined)
-    return "B only";
-  if (b8 === undefined)
-    return "A only";
-  const aJson = JSON.stringify(a5);
-  const bJson = JSON.stringify(b8);
-  if (aJson === bJson)
-    return "identical";
-  return `differs (A=${aJson.length}b, B=${bJson.length}b)`;
-}
-var PREVIEW_MAX = 120;
-function previewOutput(value) {
-  if (value == null)
-    return null;
-  if (typeof value === "string") {
-    if (value.length === 0)
-      return null;
-    return value.length > PREVIEW_MAX ? `${value.slice(0, PREVIEW_MAX - 1)}…` : value;
-  }
-  let json2;
-  try {
-    json2 = JSON.stringify(value);
-  } catch {
-    return null;
-  }
-  if (!json2 || json2 === "{}" || json2 === "[]" || json2 === "null")
-    return null;
-  const flat = json2.replace(/\s+/g, " ");
-  return flat.length > PREVIEW_MAX ? `${flat.slice(0, PREVIEW_MAX - 1)}…` : flat;
-}
-function filterIncludes(step, includes) {
-  if (!includes)
-    return step;
-  const wanted = new Set(includes.split(",").map((s5) => s5.trim()));
-  const out = { stepName: step.stepName, status: step.status };
-  if (wanted.has("input") || wanted.has("config") || wanted.has("resolvedConfig")) {
-    out.input = step.resolvedConfig;
-  }
-  if (wanted.has("inputRef") || wanted.has("inputData"))
-    out.inputRef = step.inputData;
-  if (wanted.has("output") || wanted.has("outputData"))
-    out.output = step.outputData;
-  if (wanted.has("error"))
-    out.error = step.error;
-  if (wanted.has("duration"))
-    out.durationMs = step.durationMs;
-  if ("overrideMode" in step)
-    out.overrideMode = step.overrideMode;
-  return out;
 }
 
 // src/commands/workflow/experiment-compare.ts
@@ -196226,13 +196261,13 @@ function exitUnsupported(type) {
 ` + `   redesign in EIG-104.
 
 ` + `   To run a single step today, push the workflow and run it via:
-` + `     $ eigenpal workflow execution run <workflow-id>
+` + `     $ eigenpal workflow run <workflow-id>
 ` + `     $ eigenpal workflow experiment run <workflow-id> --example-id <name>`);
   process.exit(UNSUPPORTED_TYPE_EXIT);
 }
 function registerStepExecCommands(workflow2) {
   const step = workflow2.command("step").description("Run a single workflow step (placeholder; see EIG-104).");
-  step.command("exec <type>").description("DISABLED — local mimic runners removed pending server-side redesign (EIG-104). " + "Use `workflow execution run` or `workflow experiment run` instead.").option("--config-json <json>", "(unused; kept for back-compat parsing)").option("--config-file <path>", "(unused)").option("--inputs <pairs...>", "(unused)").option("--output-schema <path>", "(unused)").action(action(async (rawType) => {
+  step.command("exec <type>").description("DISABLED — local mimic runners removed pending server-side redesign (EIG-104). " + "Use `workflow run` or `workflow experiment run` instead.").option("--config-json <json>", "(unused; kept for back-compat parsing)").option("--config-file <path>", "(unused)").option("--inputs <pairs...>", "(unused)").option("--output-schema <path>", "(unused)").action(action(async (rawType) => {
     const known = listStepTypes();
     if (!known.includes(rawType)) {
       error51(`Unknown step type: ${rawType}. Run \`eigenpal workflow step-type list\`.`);
@@ -197138,7 +197173,7 @@ YAML's \`name:\` field). Both:
   registerEvaluatorsCommands(workflow2);
   registerDatasetCommands2(workflow2);
   registerExperimentCommands2(workflow2);
-  registerWorkflowExecutionCommands(workflow2);
+  registerWorkflowRunCommand(workflow2);
   registerVersionsCommands(workflow2);
   registerStepTypeCommands(workflow2);
   registerEvaluatorTypeCommands(workflow2);
@@ -197962,7 +197997,7 @@ ${ui.bold(`✗ ${failedExecs.length}/${totalCount} did not pass`)}
     const reason = (e8.error ?? "(no error message — fetch full execution)").replace(/\s+/g, " ").slice(0, 200);
     process.stderr.write(`  ${ui.bold(label2)}  ${ui.dim(`[${e8.status}]`)} ${reason}
 `);
-    process.stderr.write(`    ${ui.dim(`eigenpal workflow execution get ${e8.id}`)}
+    process.stderr.write(`    ${ui.dim(`eigenpal runs get ${e8.id}`)}
 `);
   }
   process.stderr.write(`
@@ -198336,7 +198371,7 @@ var HELP_GROUPS = [
   },
   {
     title: "Workflows",
-    description: "Definition, evaluators, dataset, experiments, executions — all in one tree",
+    description: "Definition, evaluators, dataset, experiments, and local runs",
     commands: ["workflow"]
   },
   {
@@ -198507,7 +198542,7 @@ program2.name("eigenpal").description("Eigenpal CLI — AI workflows, evals, and
     setQuiet(true);
 });
 program2.command("status").description("One-shot dashboard: server, active tenant, user, key id, workflow count. Pair with `--json` for scripting.").option("--base-url <url>", "Server base URL").option("--json", "Emit machine-readable JSON instead of human-readable text").action(action(async (opts) => status(opts)));
-var initCmd = program2.command("init [name]").description("Scaffold a new workflow project. Without `[name]`, scaffolds into the current directory using the cwd basename as the workflow name. With `[name]`, creates `./<name>/` and uses that as the slug. The flat layout matches what `workflow execution run <slug>` already discovers — no manual file moves.").option("--template <name>", "Skip the picker; use this template").option("--dir <dir>", "Target directory (default: cwd if `[name]` omitted, else ./<name>)").option("--yes", "Non-interactive: pick the default template (blank)").action(async (name, opts) => {
+var initCmd = program2.command("init [name]").description("Scaffold a new workflow project. Without `[name]`, scaffolds into the current directory using the cwd basename as the workflow name. With `[name]`, creates `./<name>/` and uses that as the slug. The flat layout matches what `workflow run <slug>` already discovers — no manual file moves.").option("--template <name>", "Skip the picker; use this template").option("--dir <dir>", "Target directory (default: cwd if `[name]` omitted, else ./<name>)").option("--yes", "Non-interactive: pick the default template (blank)").action(async (name, opts) => {
   try {
     if (name) {
       await init(name, opts);
@@ -198554,6 +198589,7 @@ authCmd.command("use [profile]").description("Switch the active profile (persist
 });
 registerWorkflowCommands(program2);
 registerAgentCommands(program2);
+registerRunsCommands(program2);
 registerGitCommands(program2);
 program2.command("completion <shell>").description("Print a shell completion script to stdout (supported shells: bash, zsh, fish). Pipe into the appropriate completion file for your shell — see the script header for install instructions.").action(async (shell) => {
   try {