@eigenpal/cli 0.4.17 → 0.5.1

package/dist/cli.js

@@ -1019,7 +1019,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -20343,7 +20343,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -20604,7 +20604,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -27388,7 +27388,7 @@ var require_tracestate_impl = __commonJS((exports) => {
           const value = listMember.slice(i + 1, part.length);
           if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
             agg.set(key, value);
-          } else {}
+          }
         }
         return agg;
       }, new Map);
@@ -181229,7 +181229,7 @@ import { fileURLToPath as fileURLToPath6 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.4.17",
+  version: "0.5.1",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -181304,7 +181304,9 @@ var package_default = {
 
 // src/commands/agent.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync as existsSync2, promises as fs } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, promises as fs, readFileSync as readFileSync2 } from "node:fs";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
 
@@ -181387,6 +181389,15 @@ class ApiClient {
     });
     return this.handleResponse(res, url);
   }
+  async put(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    return this.handleResponse(res, url);
+  }
   async patch(path, body) {
     const url = `${this.baseUrl}${path}`;
     const res = await fetch(url, {
@@ -181948,6 +181959,7 @@ Examples:
 Version flags are intentionally unsupported for agents in this release.
 `).action(action(pushAgent));
   withBaseUrl(agent.command("pull <agent-id-or-slug>")).description("Download an agent project as agent.yaml, agent/, and dataset/.").option("--out <dir>", "Output directory").action(action(pullAgent));
+  registerAgentFileCommands(agent);
   addJsonFlag(agent.command("validate [dir]")).description("Validate a local agent project layout.").action(action(validateAgentCommand));
   registerDatasetCommands(agent);
   registerExecutionCommands(agent);
@@ -181957,6 +181969,16 @@ Version flags are intentionally unsupported for agents in this release.
   registerComingSoon(agent, "evaluators", "Agent evaluators are reserved for future workflow-style evaluators.");
   registerComingSoon(agent, "versions", "Agent versions are coming soon.");
 }
+function registerAgentFileCommands(agent) {
+  const file2 = agent.command("file").description("List, download, and upload individual live agent files.").action(() => {
+    process.stderr.write("`eigenpal agent file` requires a subcommand. Run `eigenpal agent file --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(file2.command("list <agent-id-or-slug>"))).description("List live files for an agent.").option("--path <prefix>", "Only list files beneath this relative path").action(action(listAgentFiles));
+  addJsonFlag(withBaseUrl(file2.command("get <agent-id-or-slug> <remote-path>"))).description("Download one live agent file.").option("--out <file>", "Output file path").action(action(getAgentFile));
+  addJsonFlag(withBaseUrl(file2.command("put <agent-id-or-slug> <remote-path> <local-path>"))).description("Upload one local file into the live agent namespace.").option("--dry-run", "Validate local file and remote path without uploading").option("--preview", "Compare remote and local file without uploading").action(action(putAgentFile));
+  addJsonFlag(withBaseUrl(file2.command("diff <agent-id-or-slug> <remote-path> <local-path>"))).description("Compare one live agent file against a local file.").action(action(diffAgentFile));
+}
 function registerDatasetCommands(agent) {
   const dataset = agent.command("dataset").description("Manage an agent dataset.").action(() => {
     process.stderr.write("`eigenpal agent dataset` requires a subcommand. Run `eigenpal agent dataset --help`.\n");
@@ -181973,8 +181995,24 @@ function registerExecutionCommands(agent) {
     process.exit(2);
   });
   addJsonFlag(withBaseUrl(execution.command("run <agent-id-or-slug>"))).description("Start one agent execution.").option("--input-json <json>", "JSON input object").option("--input-file <path>", "Input file to upload as multipart form-data").option("--wait", "Poll until the execution reaches a terminal status").action(action(runExecution));
-  addJsonFlag(withBaseUrl(execution.command("get <execution-id>"))).description("Get one agent execution.").option("--include <parts>", "Comma-separated extra parts, e.g. files").action(action(getExecution));
-  addJsonFlag(withPagination(withBaseUrl(execution.command("list <agent-id-or-slug>")), 50)).description("List agent executions.").option("--status <status>", "Filter by status").action(action(listExecutions));
+  addJsonFlag(withBaseUrl(execution.command("get <execution-id>"))).description("Get one agent execution.").option("--include <parts>", "Comma-separated extra parts: feedback,expected,files,trace,issues", "feedback").action(action(getExecution));
+  addJsonFlag(withBaseUrl(execution.command("rerun <execution-id>"))).description("Create a new execution from a previous execution's stored input snapshot.").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(rerunExecution));
+  const list = addJsonFlag(withPagination(withBaseUrl(execution.command("list <agent-id-or-slug>")), 50)).description("List agent executions.").option("--status <status>", "Filter by status").option("--batch-id <id>", "Filter by experiment batch id").option("--example-name <name>", "Filter by exact dataset example name").option("--example-name-contains <q>", "Filter by substring in example name").option("--created-after <time>", "Filter by created-at lower bound").option("--created-before <time>", "Filter by created-at upper bound").option("--completed-after <time>", "Filter by completed-at lower bound").option("--completed-before <time>", "Filter by completed-at upper bound").option("--feedback-status <open|resolved|ignored>", "Filter by feedback status").option("--feedback-rating <pass|fail|partial|none>", "Filter by feedback rating").option("--feedback-body-contains <q>", "Filter by feedback body substring").option("--feedback-created-after <time>", "Filter by feedback created-at lower bound").option("--feedback-created-before <time>", "Filter by feedback created-at upper bound").option("--feedback-updated-after <time>", "Filter by feedback updated-at lower bound").option("--feedback-updated-before <time>", "Filter by feedback updated-at upper bound").option("--feedback-resolved-after <time>", "Filter by feedback resolved-at lower bound").option("--feedback-resolved-before <time>", "Filter by feedback resolved-at upper bound").option("--has-feedback", "Only executions with feedback").option("--no-feedback", "Only executions without feedback").option("--has-expected", "Only executions with expected JSON or files").option("--has-expected-json", "Only executions with expected.json").option("--has-expected-files", "Only executions with expected files").option("--promoted-to-example", "Only executions promoted to dataset examples").option("--promoted-example-name <name>", "Filter by promoted dataset example name").option("--since-last-resolved", "Only executions created after the latest resolved feedback").option("--include <parts>", "Comma-separated extra parts: feedback,expected,files").option("--compact", "Return/print compact triage rows without full output payloads").option("--sort <field>", "Sort by createdAt, completedAt, status, or exampleName").option("--order <asc|desc>", "Sort direction").option("--scan-limit <n>", "Feedback scan window for feedback filters", intArg).action(action(listExecutions));
+  list.addHelpText("after", `
+Examples:
+  $ eigenpal agent execution list incorporator --feedback-rating fail --since-last-resolved --include feedback,expected
+  $ eigenpal agent execution list activities --has-expected-files --created-after 2026-05-01
+`);
+  withBaseUrl(execution.command("pull <execution-id>")).description("Download execution feedback, expected artifacts, files, and metadata.").option("--out <dir>", "Output directory").option("--include <parts>", "Comma-separated parts: feedback,expected,files,output,input,metadata,issues,trace,all", "feedback,expected").option("--json", "Output a JSON summary of written artifacts").action(action(pullExecution));
+  addJsonFlag(withBaseUrl(execution.command("compare <reference-execution-id> <execution-id>"))).description("Compare one execution against another execution. PDF/DOCX text comparison uses pdftotext/python3 and reports byte fallbacks.").option("--baseline", "Compare actual outputs from both executions 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(compareExecution));
+  const artifacts = execution.command("artifacts").description("Inspect execution artifact inventory.").action(() => {
+    process.stderr.write("`eigenpal agent execution artifacts` requires a subcommand. Run `eigenpal agent execution artifacts --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(artifacts.command("list <execution-id>"))).description("List available execution artifacts without downloading them.").action(action(listExecutionArtifacts));
+  withBaseUrl(execution.command("trace <execution-id>")).description("Print raw trace.jsonl for an execution, or write it with --out.").option("--out <file>", "Output file path").action(action(traceExecution));
+  registerExecutionFeedbackCommands(execution);
+  registerExecutionExpectedCommands(execution);
   addJsonFlag(withBaseUrl(execution.command("watch <execution-id>"))).description("Watch an execution 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(watchExecutionCommand));
   addJsonFlag(withBaseUrl(execution.command("cancel <execution-id>"))).description("Cancel an agent execution.").option("--yes", "Required in non-interactive environments").action(action(cancelExecution));
 }
@@ -181990,6 +182028,27 @@ function registerExperimentCommands(agent) {
   addJsonFlag(withBaseUrl(experiment.command("compare <batch-id-a> <batch-id-b>"))).description("Compare two experiment batches.").option("--sort <mode>", "Accepted for compatibility; sorting happens client-side later").option("--regression-threshold <n>", "Accepted for compatibility", intArg).action(action(compareExperiments));
   addJsonFlag(withBaseUrl(experiment.command("cancel <agent-id-or-slug> <batch-id>"))).description("Cancel every active execution in an experiment.").option("--yes", "Required in non-interactive environments").action(action(cancelExperiment));
 }
+function registerExecutionFeedbackCommands(execution) {
+  const feedback = execution.command("feedback").description("Update or clear feedback attached to an agent execution.").action(() => {
+    process.stderr.write("`eigenpal agent execution feedback` requires a subcommand. Run `eigenpal agent execution feedback --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(feedback.command("update <execution-id>"))).description("Edit feedback state, rating, message, or expected JSON for an execution.").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(updateExecutionFeedback));
+  addJsonFlag(withBaseUrl(feedback.command("resolve <execution-id>"))).description("Mark execution feedback as resolved.").option("--message <text>", "Set feedback message body").option("--message-file <path>", "Read feedback message body from a file").action(action((executionId, opts) => updateExecutionFeedback(executionId, { ...opts, status: "resolved" })));
+  addJsonFlag(withBaseUrl(feedback.command("clear <execution-id>"))).description("Delete feedback, expected.json, and expected files for an execution.").option("--yes", "Required in non-interactive environments").action(action(clearExecutionFeedback));
+}
+function registerExecutionExpectedCommands(execution) {
+  const expected = execution.command("expected").description("Manage expected artifacts attached to an agent execution.").action(() => {
+    process.stderr.write("`eigenpal agent execution expected` requires a subcommand. Run `eigenpal agent execution expected --help`.\n");
+    process.exit(2);
+  });
+  addJsonFlag(withBaseUrl(expected.command("list <execution-id>"))).description("List expected JSON and files attached to an execution.").action(action(listExecutionExpected));
+  withBaseUrl(expected.command("pull <execution-id>")).description("Download expected JSON and files attached to an execution.").option("--out <dir>", "Output directory").action(action(pullExecutionExpected));
+  addJsonFlag(withBaseUrl(expected.command("upload <execution-id> <file>"))).description("Upload a local file as an expected artifact.").option("--name <name>", "Expected artifact name").action(action(uploadExecutionExpected));
+  addJsonFlag(withBaseUrl(expected.command("copy-output <execution-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 <execution-id> <old-name> <new-name>"))).description("Rename an expected artifact.").action(action(renameExecutionExpected));
+  addJsonFlag(withBaseUrl(expected.command("delete <execution-id> <name>"))).description("Delete an expected artifact.").option("--yes", "Required in non-interactive environments").action(action(deleteExecutionExpected));
+}
 function registerSessionCommands(agent) {
   const session = agent.command("session").description("Manage agent builder sessions.").action(() => {
     process.stderr.write("`eigenpal agent session` requires a subcommand. Run `eigenpal agent session --help`.\n");
@@ -182108,6 +182167,55 @@ async function pullAgent(agentId, opts) {
   await pullDataset(agentId, { ...opts, out: path.join(out, DATASET_DIR) });
   success2(`Pulled agent to ${ui.bold(out)}`);
 }
+async function listAgentFiles(agentId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/files`, {
+    ...opts.path ? { prefix: opts.path } : {}
+  });
+  if (opts.json)
+    return printJson(payload);
+  console.log(table((payload.files ?? []).map((name) => ({ name })), [{ key: "name", header: "PATH" }]));
+}
+async function getAgentFile(agentId, remotePath, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/files`, {
+    path: remotePath
+  });
+  if (opts.json)
+    return printJson(payload);
+  const out = path.resolve(opts.out ?? payload.path);
+  await writeBase64File(out, payload.contentBase64);
+  success2(`Downloaded ${payload.path} to ${ui.bold(out)}`);
+}
+async function putAgentFile(agentId, remotePath, localPath, opts) {
+  const absolute = path.resolve(localPath);
+  const data = await fs.readFile(absolute);
+  if (opts.dryRun) {
+    const payload2 = { ok: true, dryRun: true, path: remotePath, bytes: data.length };
+    if (opts.json)
+      return printJson(payload2);
+    success2(`Validated ${remotePath} from ${ui.bold(absolute)} (${data.length} bytes)`);
+    return;
+  }
+  if (opts.preview) {
+    const report = await buildAgentFileDiff(agentId, remotePath, absolute, opts);
+    if (opts.json)
+      return printJson(report);
+    renderAgentFileDiff(report);
+    return;
+  }
+  const client = buildClient(opts);
+  const payload = await client.put(`/api/v1/agents/${encodeURIComponent(agentId)}/files?path=${encodeURIComponent(remotePath)}`, { contentBase64: data.toString("base64") });
+  if (opts.json)
+    return printJson(payload);
+  success2(`Uploaded ${remotePath} from ${ui.bold(absolute)}`);
+}
+async function diffAgentFile(agentId, remotePath, localPath, opts) {
+  const report = await buildAgentFileDiff(agentId, remotePath, path.resolve(localPath), opts);
+  if (opts.json)
+    return printJson(report);
+  renderAgentFileDiff(report);
+}
 async function validateAgentCommand(dir = ".", opts) {
   const result = await validateAgentProject(path.resolve(dir));
   if (opts.json)
@@ -182184,18 +182292,302 @@ async function getExecution(executionId, opts) {
   });
   renderExecutionPayload(payload, opts);
 }
-async function listExecutions(agentId, opts) {
+async function rerunExecution(executionId, opts) {
   const client = buildClient(opts);
-  const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/executions`, compactParams(opts));
+  let payload = await client.post(`/api/v1/agents/executions/${encodeURIComponent(executionId)}/rerun`, {});
+  const rerunId = String(payload.executionId ?? "");
+  if (opts.wait && rerunId) {
+    payload = await pollExecution(client, rerunId, opts.interval, opts.maxWait);
+    return renderExecutionPayload(payload, opts);
+  }
   if (opts.json)
     return printJson(payload);
-  console.log(table(payload.executions, [
+  success2(`Started rerun ${ui.bold(rerunId)} from ${executionId}`);
+}
+async function pullExecution(executionId, opts) {
+  const client = buildClient(opts);
+  const include = new Set(opts.include.split(",").map((part) => part.trim()).filter(Boolean));
+  if (include.has("all")) {
+    include.add("feedback");
+    include.add("expected");
+    include.add("files");
+    include.add("input");
+    include.add("output");
+    include.add("metadata");
+    include.add("issues");
+    include.add("trace");
+  }
+  const payload = await client.get(`/api/v1/agents/executions/${encodeURIComponent(executionId)}`, { include: [...include].join(",") });
+  const execution = payload.execution;
+  if (!execution)
+    throw new Error(`Execution ${executionId} not found`);
+  const out = path.resolve(opts.out ?? path.join(".eigenpal", "artifacts", "executions", executionId));
+  await fs.mkdir(out, { recursive: true });
+  const written = [];
+  const skipped = [];
+  const writeJsonArtifact = async (name, value) => {
+    await fs.writeFile(path.join(out, name), JSON.stringify(value, null, 2));
+    written.push(name);
+  };
+  await writeJsonArtifact("execution.json", execution);
+  const feedback = execution.feedback;
+  if (include.has("feedback") && feedback) {
+    await fs.writeFile(path.join(out, "feedback.md"), serializeCliFeedback(feedback));
+    written.push("feedback.md");
+  } else if (include.has("feedback")) {
+    skipped.push("feedback");
+  }
+  if (include.has("expected")) {
+    written.push(...await writeExpectedArtifacts(client, executionId, out, execution));
+  }
+  if (include.has("files") || include.has("output")) {
+    written.push(...await writeListedFiles(client, executionId, out, "output", execution.resultFiles));
+  }
+  if (include.has("files") || include.has("input")) {
+    written.push(...await writeListedFiles(client, executionId, out, "input", execution.inputFiles));
+    if (execution.inputJson) {
+      await writeJsonArtifact("input.json", execution.inputJson);
+    } else {
+      skipped.push("input.json");
+    }
+  }
+  if (include.has("files") || include.has("metadata")) {
+    if (execution.metadata) {
+      await writeJsonArtifact("metadata.json", execution.metadata);
+    } else {
+      skipped.push("metadata.json");
+    }
+  }
+  if (include.has("files") || include.has("issues")) {
+    const file2 = await writeDiagnosticFile(client, executionId, out, "issues", "issues.md", execution.issueFiles);
+    if (file2)
+      written.push(file2);
+    else
+      skipped.push("issues.md");
+  }
+  if (include.has("files") || include.has("trace")) {
+    const file2 = await writeDiagnosticFile(client, executionId, out, "trace", "trace.jsonl", execution.traceFiles);
+    if (file2)
+      written.push(file2);
+    else
+      skipped.push("trace.jsonl");
+  }
+  const summary = {
+    executionId,
+    out,
+    written,
+    skipped,
+    counts: {
+      written: written.length,
+      skipped: skipped.length
+    }
+  };
+  if (opts.json)
+    return printJson(summary);
+  success2(`Pulled execution ${executionId} to ${out}`);
+  dim(`Wrote ${written.length} artifact${written.length === 1 ? "" : "s"}${skipped.length ? `; skipped missing ${skipped.join(", ")}` : ""}`);
+}
+async function listExecutionArtifacts(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/agents/executions/${encodeURIComponent(executionId)}`, { include: "expected,files,input,output,issues,trace,metadata" });
+  const execution = payload.execution;
+  if (!execution)
+    throw new Error(`Execution ${executionId} not found`);
+  const artifacts = executionArtifactInventory(execution);
+  if (opts.json)
+    return printJson({ executionId, artifacts });
+  console.log(table(artifacts, [
+    { key: "kind", header: "KIND" },
+    { key: "name", header: "NAME" },
+    { key: "present", header: "PRESENT" }
+  ]));
+}
+async function traceExecution(executionId, opts) {
+  const client = buildClient(opts);
+  const text = await downloadTraceText(client, executionId);
+  if (!opts.out) {
+    process.stdout.write(text);
+    return;
+  }
+  const out = path.resolve(opts.out);
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  await fs.writeFile(out, text);
+  success2(`Downloaded trace for ${executionId} to ${ui.bold(out)}`);
+}
+async function compareExecution(referenceId, executionId, opts) {
+  const client = buildClient(opts);
+  const targetPayload = await client.get(`/api/v1/agents/executions/${encodeURIComponent(executionId)}`, { include: "files,output" });
+  const target = targetPayload.execution;
+  if (!target)
+    throw new Error(`Execution ${executionId} not found`);
+  const mode = opts.baseline ? "baseline" : "expected";
+  const reference = (await client.get(`/api/v1/agents/executions/${encodeURIComponent(referenceId)}`, {
+    include: mode === "baseline" ? "files,output" : "expected"
+  })).execution;
+  if (!reference)
+    throw new Error(`Reference execution ${referenceId} not found`);
+  const out = path.resolve(opts.out ?? path.join(".eigenpal", "artifacts", "comparisons", `${referenceId}..${executionId}`));
+  await fs.mkdir(out, { recursive: true });
+  const warnings = [];
+  if (mode === "expected" && reference.expected == null && fileNames(reference.expectedFiles).length === 0) {
+    warnings.push(`Reference execution ${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, { executionId: referenceId, kind: mode === "baseline" ? "output" : "expected" }, { 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",
+    executionId,
+    comparedWith: referenceId,
+    mode,
+    warnings,
+    jsonDifferences: jsonDiffs,
+    matchedFiles: inventory.matched,
+    missingFiles: inventory.missing,
+    extraFiles: inventory.extra,
+    textDifferences
+  };
+  await fs.writeFile(path.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 listExecutions(agentId, opts) {
+  const client = buildClient(opts);
+  const params = buildExecutionListParams(opts);
+  const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/executions`, params);
+  const rows = opts.compact ? payload.executions.map(compactExecutionRow) : payload.executions;
+  if (opts.json)
+    return printJson({ ...payload, executions: 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 buildExecutionListParams(opts) {
+  return compactParams({
+    ...opts,
+    feedback: undefined,
+    noFeedback: opts.noFeedback ?? (opts.feedback === false ? true : undefined)
+  });
+}
+async function updateExecutionFeedback(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 fs.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 fs.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/executions/${encodeURIComponent(executionId)}/feedback`, body);
+  renderGeneric(payload, opts, `Updated feedback for ${executionId}`);
+}
+function compactExecutionRow(execution) {
+  const feedback = execution.feedback && typeof execution.feedback === "object" ? execution.feedback : null;
+  return {
+    id: execution.id,
+    status: execution.status,
+    exampleId: execution.exampleId,
+    feedback: feedback ? {
+      rating: feedback.rating ?? null,
+      status: feedback.status ?? null,
+      updatedAt: feedback.updatedAt ?? null
+    } : null,
+    hasExpectedJson: execution.expected != null,
+    expectedFileCount: Array.isArray(execution.expectedFiles) ? execution.expectedFiles.length : undefined,
+    createdAt: execution.createdAt,
+    completedAt: execution.completedAt
+  };
+}
+async function clearExecutionFeedback(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/executions/${encodeURIComponent(executionId)}/feedback`);
+  renderGeneric(payload, opts, `Cleared feedback for ${executionId}`);
+}
+async function listExecutionExpected(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/agents/executions/${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 pullExecutionExpected(executionId, opts) {
+  const client = buildClient(opts);
+  const payload = await client.get(`/api/v1/agents/executions/${encodeURIComponent(executionId)}/expected`);
+  const out = path.resolve(opts.out ?? path.join(executionId, "expected"));
+  await fs.mkdir(out, { recursive: true });
+  if (payload.expected != null) {
+    await fs.writeFile(path.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 uploadExecutionExpected(executionId, file2, opts) {
+  const client = buildClient(opts);
+  const form = new FormData;
+  const data = await fs.readFile(file2);
+  form.append("file", new Blob([data]), path.basename(file2));
+  if (opts.name)
+    form.append("name", opts.name);
+  const payload = await client.postFormData(`/api/v1/agents/executions/${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/executions/${encodeURIComponent(executionId)}/expected`, { outputFileName: outputFile, ...opts.name ? { expectedName: opts.name } : {} });
+  renderGeneric(payload, opts, `Copied output file to expected for ${executionId}`);
+}
+async function renameExecutionExpected(executionId, oldName, newName, opts) {
+  const client = buildClient(opts);
+  const payload = await client.patch(`/api/v1/agents/executions/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(oldName)}`, { name: newName });
+  renderGeneric(payload, opts, `Renamed expected file for ${executionId}`);
+}
+async function deleteExecutionExpected(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/executions/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
+  renderGeneric({ ok: true }, opts, `Deleted expected file ${name}`);
+}
 async function watchExecutionCommand(executionId, opts) {
   const client = buildClient(opts);
   const payload = await pollExecution(client, executionId, opts.interval, opts.maxWait);
@@ -182410,6 +182802,336 @@ async function buildAgentExecutionRunFormData(inputFile, inputJson) {
     form.append("_json", inputJson);
   return form;
 }
+function serializeCliFeedback(feedback) {
+  const keys = [
+    "rating",
+    "status",
+    "createdAt",
+    "createdBy",
+    "createdByEmail",
+    "updatedAt",
+    "resolvedAt",
+    "resolvedBy",
+    "resolvedByEmail",
+    "resolvedBySessionId",
+    "promotedExampleName"
+  ];
+  const frontmatter = keys.map((key) => `${key}: ${feedback[key] ?? ""}`).join(`
+`);
+  return `---
+${frontmatter}
+---
+
+${String(feedback.body ?? "").trim()}
+`;
+}
+async function writeExpectedArtifacts(client, executionId, out, execution) {
+  const written = [];
+  const expectedDir = path.join(out, "expected");
+  await fs.mkdir(expectedDir, { recursive: true });
+  if (execution.expected != null) {
+    await fs.writeFile(path.join(out, "expected.json"), JSON.stringify(execution.expected, null, 2));
+    written.push("expected.json");
+  }
+  written.push(...(await downloadExpectedFiles(client, executionId, expectedDir, execution.expectedFiles)).map((name) => `expected/${name}`));
+  return written;
+}
+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/executions/${encodeURIComponent(executionId)}/expected/${encodeURIComponent(name)}`);
+    await fs.mkdir(out, { recursive: true });
+    await fs.writeFile(path.join(out, name), Buffer.from(await response.arrayBuffer()));
+    return name;
+  }));
+  return written.filter((name) => Boolean(name));
+}
+async function writeListedFiles(client, executionId, out, kind, files) {
+  const rows = Array.isArray(files) ? files : [];
+  const targetDir = path.join(out, kind);
+  await fs.mkdir(targetDir, { recursive: true });
+  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/executions/${encodeURIComponent(executionId)}/files/${kind}/${encodeURIComponent(name)}`);
+    await fs.writeFile(path.join(targetDir, name), Buffer.from(await response.arrayBuffer()));
+    return `${kind}/${name}`;
+  }));
+  return written.filter((name) => Boolean(name));
+}
+async function writeDiagnosticFile(client, executionId, out, kind, filename, files) {
+  const rows = Array.isArray(files) ? files : [];
+  const exists = rows.some((file2) => String(file2.name ?? "") === filename);
+  if (!exists)
+    return null;
+  const response = await client.getStream(`/api/v1/agents/executions/${encodeURIComponent(executionId)}/files/${kind}/${filename}`);
+  await fs.writeFile(path.join(out, filename), Buffer.from(await response.arrayBuffer()));
+  return filename;
+}
+async function downloadTraceText(client, executionId) {
+  const response = await client.getStream(`/api/v1/agents/executions/${encodeURIComponent(executionId)}/files/trace/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 executionArtifactInventory(execution) {
+  const rows = [
+    { kind: "metadata", name: "execution.json", present: "yes" }
+  ];
+  if (execution.inputJson != null)
+    rows.push({ kind: "input", name: "input.json", present: "yes" });
+  if (execution.metadata != null)
+    rows.push({ kind: "metadata", name: "metadata.json", present: "yes" });
+  if (execution.expected != null)
+    rows.push({ kind: "expected", name: "expected.json", present: "yes" });
+  for (const name of fileNames(execution.inputFiles))
+    rows.push({ kind: "input", name, present: "yes" });
+  for (const name of fileNames(execution.resultFiles).filter((name2) => name2 !== "issues.md" && name2 !== "trace.jsonl")) {
+    rows.push({ kind: "output", name, present: "yes" });
+  }
+  for (const name of fileNames(execution.expectedFiles)) {
+    rows.push({ kind: "expected", name, present: "yes" });
+  }
+  for (const name of fileNames(execution.issueFiles))
+    rows.push({ kind: "issues", name, present: "yes" });
+  for (const name of fileNames(execution.traceFiles))
+    rows.push({ kind: "trace", name, present: "yes" });
+  return rows.sort((a, b) => `${a.kind}/${a.name}`.localeCompare(`${b.kind}/${b.name}`));
+}
+async function buildAgentFileDiff(agentId, remotePath, localPath, opts) {
+  const client = buildClient(opts);
+  const local = await fs.readFile(localPath);
+  let remote = null;
+  let serverPath = remotePath;
+  try {
+    const payload = await client.get(`/api/v1/agents/${encodeURIComponent(agentId)}/files`, {
+      path: remotePath
+    });
+    serverPath = String(payload.path ?? remotePath);
+    remote = Buffer.from(String(payload.contentBase64 ?? ""), "base64");
+  } catch (err) {
+    if (!(err instanceof ApiError) || err.status !== 404)
+      throw err;
+  }
+  const localHash = createHash("sha256").update(local).digest("hex");
+  const remoteHash = remote ? createHash("sha256").update(remote).digest("hex") : null;
+  const status = !remote ? "remote-missing" : localHash === remoteHash ? "match" : "different";
+  return {
+    agentId,
+    path: serverPath,
+    localPath,
+    status,
+    localBytes: local.length,
+    remoteBytes: remote?.length ?? null,
+    localSha256: localHash,
+    remoteSha256: remoteHash,
+    textPreview: remote && isLikelyText(local) && isLikelyText(remote) ? buildTextDiffPreview(remote.toString("utf-8"), local.toString("utf-8")) : null
+  };
+}
+function renderAgentFileDiff(report) {
+  const label = `File ${report.status}`;
+  if (report.status === "match")
+    success2(label);
+  else
+    error51(label);
+  console.log(table([
+    { item: "Remote path", value: report.path },
+    { item: "Local bytes", value: String(report.localBytes) },
+    { item: "Remote bytes", value: String(report.remoteBytes ?? "missing") },
+    { item: "Local sha256", value: report.localSha256.slice(0, 12) },
+    { item: "Remote sha256", value: report.remoteSha256?.slice(0, 12) ?? "missing" }
+  ], [
+    { key: "item", header: "ITEM" },
+    { key: "value", header: "VALUE" }
+  ]));
+  if (report.textPreview?.length) {
+    console.log(report.textPreview.join(`
+`));
+  }
+}
+function isLikelyText(buffer) {
+  return !buffer.includes(0);
+}
+function buildTextDiffPreview(remoteText, localText) {
+  if (remoteText === localText)
+    return [];
+  const remoteLines = remoteText.split(/\r?\n/);
+  const localLines = localText.split(/\r?\n/);
+  const max = Math.max(remoteLines.length, localLines.length);
+  const preview = [];
+  for (let index = 0;index < max && preview.length < 12; index += 1) {
+    if (remoteLines[index] === localLines[index])
+      continue;
+    preview.push(`-${remoteLines[index] ?? ""}`);
+    preview.push(`+${localLines[index] ?? ""}`);
+  }
+  return preview;
+}
+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((expectedName) => {
+    const outputName = outputByNormalized.get(normalize(expectedName));
+    return outputName ? { expected: expectedName, 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 = path.join(out, "expected");
+  const outputDir = path.join(out, "output");
+  await fs.mkdir(expectedDir, { recursive: true });
+  await fs.mkdir(outputDir, { recursive: true });
+  const diffs = [];
+  for (const pair of matched) {
+    const expectedPath = path.join(expectedDir, pair.expected);
+    const outputPath = path.join(outputDir, pair.output);
+    await downloadStreamToFile(client, executionFileUrl(left, pair.expected), expectedPath);
+    await downloadStreamToFile(client, executionFileUrl(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([
+        fs.readFile(expectedPath),
+        fs.readFile(outputPath)
+      ]);
+      const expectedHash = createHash("sha256").update(expectedBuffer).digest("hex");
+      const outputHash = createHash("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 executionFileUrl(side, name) {
+  const executionId = encodeURIComponent(side.executionId);
+  const filename = encodeURIComponent(name);
+  return side.kind === "expected" ? `/api/v1/agents/executions/${executionId}/expected/${filename}` : `/api/v1/agents/executions/${executionId}/files/output/${filename}`;
+}
+async function downloadStreamToFile(client, url2, target) {
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  const response = await client.getStream(url2);
+  await fs.writeFile(target, Buffer.from(await response.arrayBuffer()));
+}
+function extractComparableText(file2) {
+  const ext = path.extname(file2).toLowerCase();
+  if ([".txt", ".md", ".json", ".csv", ".xml"].includes(ext)) {
+    return { text: readFileSync2(file2, "utf8") };
+  }
+  if (ext === ".pdf") {
+    const result = spawnSync("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 = spawnSync("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}`);
+    }
+  }
+}
 async function readAgentYaml(root) {
   const file2 = path.join(root, AGENT_YAML);
   const raw = await fs.readFile(file2, "utf-8");
@@ -182490,7 +183212,7 @@ function renderGeneric(payload, opts, message) {
 function compactParams(opts) {
   const params = {};
   for (const [key, value] of Object.entries(opts)) {
-    if (value === undefined || value === null || key === "json" || key === "baseUrl" || key === "yes")
+    if (value === undefined || value === null || key === "json" || key === "baseUrl" || key === "yes" || key === "compact")
       continue;
     params[key] = String(value);
   }
@@ -183007,7 +183729,7 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -183105,7 +183827,7 @@ function copyTemplate(src, dst, projectName) {
       }
       mkdirSync2(dirname2(targetPath), { recursive: true });
       if (isTextFile(sourcePath)) {
-        const text = readFileSync2(sourcePath, "utf-8").replaceAll(PLACEHOLDER, projectName);
+        const text = readFileSync3(sourcePath, "utf-8").replaceAll(PLACEHOLDER, projectName);
         writeFileSync2(targetPath, text);
       } else {
         copyFileSync(sourcePath, targetPath);
@@ -183137,12 +183859,12 @@ function isTextFile(path2) {
 
 // src/commands/skill.ts
 init_dist4();
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
   existsSync as existsSync4,
   lstatSync,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   readdirSync as readdirSync2,
   rmSync,
   rmdirSync,
@@ -183236,7 +183958,7 @@ function resolveSkillTarget(opts) {
   return opts.target ?? defaultClaudeTarget();
 }
 function sha256(buffer) {
-  return createHash("sha256").update(buffer).digest("hex");
+  return createHash2("sha256").update(buffer).digest("hex");
 }
 var CLI_VERSION_PLACEHOLDER = "__CLI_VERSION__";
 function templateSourceFile(relativePath, bytes, cliVersion) {
@@ -183260,7 +183982,7 @@ async function installSkill(opts) {
   for (const relativePath of sourceFiles) {
     const sourcePath = join3(source, relativePath);
     const targetPath = join3(target, relativePath);
-    const sourceBytes = templateSourceFile(relativePath, readFileSync3(sourcePath), cliVersion);
+    const sourceBytes = templateSourceFile(relativePath, readFileSync4(sourcePath), cliVersion);
     const sourceHash = sha256(sourceBytes);
     if (!existsSync4(targetPath)) {
       mkdirSync3(dirname3(targetPath), { recursive: true });
@@ -183268,7 +183990,7 @@ async function installSkill(opts) {
       written += 1;
       continue;
     }
-    const targetBytes = readFileSync3(targetPath);
+    const targetBytes = readFileSync4(targetPath);
     const targetHash = sha256(targetBytes);
     if (targetHash === sourceHash) {
       skipped += 1;
@@ -183299,7 +184021,7 @@ async function installSkill(opts) {
     const targetPath = join3(target, relativePath);
     if (!existsSync4(targetPath))
       continue;
-    manifestEntries.push({ path: relativePath, sha256: sha256(readFileSync3(targetPath)) });
+    manifestEntries.push({ path: relativePath, sha256: sha256(readFileSync4(targetPath)) });
   }
   const manifest = {
     cliVersion,
@@ -183340,7 +184062,7 @@ async function uninstallSkill(opts) {
     }
     if (!existsSync4(path2))
       continue;
-    const currentHash = sha256(readFileSync3(path2));
+    const currentHash = sha256(readFileSync4(path2));
     if (currentHash !== entry.sha256 && !opts.yes) {
       kept += 1;
       continue;
@@ -183570,7 +184292,7 @@ function readManifest(target) {
   if (!existsSync4(path2))
     return null;
   try {
-    return JSON.parse(readFileSync3(path2, "utf-8"));
+    return JSON.parse(readFileSync4(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -183584,7 +184306,7 @@ function readCliVersion() {
     ];
     for (const candidate of candidates) {
       if (existsSync4(candidate)) {
-        const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync4(candidate, "utf-8"));
         if (pkg.version)
           return pkg.version;
       }
@@ -184386,8 +185108,8 @@ import path15 from "node:path";
 import { createInterface as createInterface3 } from "node:readline/promises";
 
 // src/lib/format-eigenpal.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join4, resolve as resolve3 } from "path";
 var PRETTRC_NAMES = [
   ".prettierrc",
@@ -184408,7 +185130,7 @@ function hasPrettierConfig(cwd) {
     const pkgPath = join4(cwd, "package.json");
     if (!existsSync5(pkgPath))
       return false;
-    const raw = readFileSync4(pkgPath, "utf-8");
+    const raw = readFileSync5(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     return pkg != null && typeof pkg === "object" && "prettier" in pkg;
   } catch {
@@ -184423,7 +185145,7 @@ function formatEigenpalDirIfAvailable(dir) {
   if (!hasPrettierConfig(cwd))
     return;
   const runner = typeof Bun !== "undefined" ? "bunx" : "npx";
-  spawnSync(runner, ["prettier", "--write", absDir], {
+  spawnSync2(runner, ["prettier", "--write", absDir], {
     cwd,
     stdio: "ignore",
     shell: false
@@ -184509,7 +185231,7 @@ import { existsSync as existsSync7, readdirSync as readdirSync4, rmSync as rmSyn
 import { basename, join as join7 } from "path";
 
 // src/lib/payload.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
 import { join as join6 } from "path";
 
 // src/lib/fs-helpers.ts
@@ -184566,7 +185288,7 @@ function getExampleNames(dir, exampleNamesFilter) {
 function readInput(exampleDir) {
   const argsPath = join6(exampleDir, "input", "arguments.json");
   const inputDir = join6(exampleDir, "input");
-  const scalars = JSON.parse(readFileSync5(argsPath, "utf-8"));
+  const scalars = JSON.parse(readFileSync6(argsPath, "utf-8"));
   const files = [];
   for (const entry of readdirSync3(inputDir)) {
     const full = join6(inputDir, entry);
@@ -184577,7 +185299,7 @@ function readInput(exampleDir) {
       files.push({
         argument: entry,
         filename,
-        content: readFileSync5(join6(full, filename)),
+        content: readFileSync6(join6(full, filename)),
         mimeType: guessMimeType(filename)
       });
     }
@@ -184588,7 +185310,7 @@ function readOverrides(exampleDir) {
   const metaPath = join6(exampleDir, "meta.json");
   if (!existsSync6(metaPath))
     return null;
-  const raw = JSON.parse(readFileSync5(metaPath, "utf-8"));
+  const raw = JSON.parse(readFileSync6(metaPath, "utf-8"));
   const ov = raw.overrides;
   if (ov && typeof ov === "object" && "steps" in ov && typeof ov.steps === "object") {
     return ov;
@@ -184845,18 +185567,18 @@ async function watchExecution(opts) {
 import { join as join11 } from "path";
 
 // src/lib/execution-artifacts.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { join as join10 } from "path";
 
 // src/lib/format.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { extname as extname3, resolve as resolve5 } from "path";
 var PRETTIER_EXTENSIONS = new Set([".json", ".yaml", ".yml"]);
 async function formatFileIfAvailable(filepath) {
   if (!PRETTIER_EXTENSIONS.has(extname3(filepath)))
     return;
   try {
-    const content = readFileSync6(filepath, "utf-8");
+    const content = readFileSync7(filepath, "utf-8");
     const prettier = await Promise.resolve().then(() => (init_prettier(), exports_prettier));
     const formatted = await prettier.format(content, {
       filepath: resolve5(filepath)
@@ -185623,7 +186345,7 @@ function parseWorkflow(yaml) {
 }
 // src/commands/validate.ts
 var import_yaml5 = __toESM(require_dist(), 1);
-import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
 import { join as join12, resolve as resolve6 } from "path";
 var NAME_RE = /^[a-z0-9][a-z0-9-_]*$/;
 function isDirSafe(path15, issues, field) {
@@ -185641,7 +186363,7 @@ function validateWorkflowYaml(path15) {
   if (!existsSync9(path15)) {
     return [{ field: path15, message: "File not found." }];
   }
-  const text = readFileSync8(path15, "utf-8");
+  const text = readFileSync9(path15, "utf-8");
   try {
     parseWorkflow(text);
     return [];
@@ -185663,7 +186385,7 @@ function validateEvaluatorsYaml(path15) {
   if (!existsSync9(path15)) {
     return [{ field: path15, message: "File not found." }];
   }
-  const text = readFileSync8(path15, "utf-8");
+  const text = readFileSync9(path15, "utf-8");
   let parsed;
   try {
     parsed = import_yaml5.parse(text);
@@ -185715,7 +186437,7 @@ function validateDatasetFolder(root2) {
     }
     let args;
     try {
-      const parsed = JSON.parse(readFileSync8(argsPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync9(argsPath, "utf-8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         issues.push({
           field: `examples/${exampleName}/input/arguments.json`,
@@ -185773,7 +186495,7 @@ function validateDatasetFolder(root2) {
       if (existsSync9(expectedPath)) {
         let parsed;
         try {
-          parsed = JSON.parse(readFileSync8(expectedPath, "utf-8"));
+          parsed = JSON.parse(readFileSync9(expectedPath, "utf-8"));
         } catch {
           issues.push({
             field: `examples/${exampleName}/expected/output.json`,
@@ -186316,7 +187038,7 @@ async function readDirAsZip(dir) {
   }
   return zipSync(tree);
 }
-async function downloadStreamToFile(client, path16, outFile) {
+async function downloadStreamToFile2(client, path16, outFile) {
   const res = await client.getStream(path16);
   const buf = Buffer.from(await res.arrayBuffer());
   if (outFile) {
@@ -186620,7 +187342,7 @@ function registerDatasetCommands2(parent) {
   const pullCmd = dataset.command("pull <workflow-id>").description(descriptionFor("workflow_get_dataset")).option("--out <zip>", "Write the dataset ZIP to this path. When omitted, the binary streams to stdout.");
   withBaseUrl(pullCmd).action(action(async (workflow2, opts) => {
     const { client, workflowId } = await buildClientForWorkflow(workflow2, opts);
-    await downloadStreamToFile(client, `/api/v1/workflows/${workflowId}/dataset/export`, opts.out);
+    await downloadStreamToFile2(client, `/api/v1/workflows/${workflowId}/dataset/export`, opts.out);
   }));
   const pushCmd = dataset.command("push <workflow-id>").description(descriptionFor("workflow_set_dataset")).requiredOption("--file <path>", "Path to a dataset ZIP file or a dataset/ folder (folder is zipped in memory before upload)").option("--mode <append|replace>", "Import mode (default: append)", "append").option("--yes", "Skip the destructive confirmation prompt for --mode replace (use in CI)", false).addHelpText("after", `
 Examples:
@@ -187069,7 +187791,7 @@ Behavior:
     const params = new URLSearchParams({ format: opts.format });
     if (batchId)
       params.set("batchId", batchId);
-    await downloadStreamToFile(client, `/api/v1/workflows/${workflowId}/eval-results/export?${params.toString()}`, opts.out);
+    await downloadStreamToFile2(client, `/api/v1/workflows/${workflowId}/eval-results/export?${params.toString()}`, opts.out);
   }));
   const compareCmd = experiment.command("compare <batchIdA> <batchIdB>").description("Diff eval scores between two experiment batches.").option("--sort <abs-delta-desc|delta-asc|delta-desc|name>", "Row sort order (default: biggest movers first)", "abs-delta-desc").option("--regression-threshold <n>", "Δ below this is flagged as a regression (default 0.05)", Number.parseFloat, 0.05).addHelpText("after", `
 Examples:
@@ -187157,7 +187879,7 @@ Behavior:
           return;
         const params = new URLSearchParams({ format: opts.format, batchId });
         try {
-          await downloadStreamToFile(client, `/api/v1/workflows/${workflowId}/eval-results/export?${params.toString()}`, dest);
+          await downloadStreamToFile2(client, `/api/v1/workflows/${workflowId}/eval-results/export?${params.toString()}`, dest);
         } catch (err2) {
           error51(`Watch finished but pulling results failed: ${err2 instanceof Error ? err2.message : String(err2)}. Re-run \`experiment results <wf> <batch>\` to retry.`);
           process.exit(1);
@@ -187358,6 +188080,39 @@ function registerStepTypeCommands(parent) {
   });
 }
 
+// src/lib/command-aliases.ts
+var CONVENTION_ALIASES = new Map([
+  ["artifacts", "artifact"],
+  ["execution", "exec"],
+  ["experiment", "exp"],
+  ["feedback", "fb"],
+  ["list", "ls"],
+  ["compare", "diff"]
+]);
+function applyCommandAliasConventions(root2) {
+  for (const command of root2.commands) {
+    applySiblingAliases(command.parent ?? root2);
+    applyCommandAliasConventions(command);
+  }
+}
+function applySiblingAliases(parent) {
+  const reserved = new Set;
+  for (const sibling of parent.commands) {
+    reserved.add(sibling.name());
+    for (const alias of sibling.aliases())
+      reserved.add(alias);
+  }
+  for (const command of parent.commands) {
+    const alias = CONVENTION_ALIASES.get(command.name());
+    if (!alias || command.aliases().includes(alias))
+      continue;
+    if (reserved.has(alias))
+      continue;
+    command.aliases([...command.aliases(), alias]);
+    reserved.add(alias);
+  }
+}
+
 // src/lib/logo.ts
 var LOGO_WIDTH = 22;
 var LOGO_LINES = [
@@ -187803,6 +188558,7 @@ skillCmd.command("list").description("Show every tool that has an Eigenpal skill
     process.exit(1);
   }
 });
+applyCommandAliasConventions(program2);
 function isEntryPoint() {
   const argv1 = process.argv[1];
   if (!argv1)