@eigenpal/cli 0.20.48 → 0.20.50

package/dist/cli.js

@@ -16814,6 +16814,14 @@ function validateWorkspaceSchema(content, _filename) {
   checkEigenpalTypeExtension(schema, "", errors);
   return { valid: errors.length === 0, errors };
 }
+function validateAgentSchema(content, filename) {
+  try {
+    const schema = JSON.parse(content);
+    if (schema !== null && typeof schema === "object" && !Array.isArray(schema) && Object.keys(schema).length === 0)
+      return { valid: true, errors: [] };
+  } catch {}
+  return validateWorkspaceSchema(content, filename);
+}
 function checkEigenpalTypeExtension(node, path, errors, seen = new WeakSet) {
   if (!node || typeof node !== "object")
     return;
@@ -56912,31 +56920,6 @@ var init_grammar = __esm(() => {
   RunTargetSchema = union([RunTargetStringSchema, RunTargetObjectSchema]);
 });
 
-// ../types/src/git-source/lockfile.ts
-import { createHash } from "node:crypto";
-function sourceLockfileInputHash(input) {
-  return createHash("sha256").update(JSON.stringify(input)).digest("hex");
-}
-var SourceLockPackageSchema, SourceLockfileSchema;
-var init_lockfile = __esm(() => {
-  init_zod();
-  init_grammar();
-  SourceLockPackageSchema = lazy(() => object({
-    packagePath: SourcePackagePathSchema,
-    requestedRef: SourceVersionRefSchema,
-    resolvedRef: string2().min(1),
-    resolvedTag: string2().min(1).optional(),
-    commit: string2().regex(SOURCE_COMMIT_SHA_PATTERN),
-    dependencies: array(SourceLockPackageSchema)
-  }));
-  SourceLockfileSchema = object({
-    lockfileVersion: literal(1),
-    eigenpalVersion: string2().min(1),
-    inputHash: string2().min(1),
-    root: SourceLockPackageSchema
-  });
-});
-
 // ../types/src/git-source/manifests.ts
 function workspaceDependencyNameToPackagePath(name) {
   const parsedName = WorkspaceDependencyNameSchema.parse(name);
@@ -57180,6 +57163,58 @@ var init_manifests = __esm(() => {
   SOURCE_TEMPLATE_FILE_PATTERN = /\.(?:docx|xlsx)$/i;
 });
 
+// ../types/src/git-source/agent-definition.ts
+var CompiledAgentDataSchema, CompiledAgentSnapshotSchema;
+var init_agent_definition = __esm(() => {
+  init_zod();
+  init_manifests();
+  CompiledAgentDataSchema = strictObject({
+    schemaVersion: literal(1),
+    kind: literal("agent"),
+    manifest: unknown().refine((value) => AgentPackageManifestSchema.safeParse(value).success, "Invalid agent manifest"),
+    inputSchema: record(string2(), unknown()).optional(),
+    outputSchema: record(string2(), unknown()).optional()
+  });
+  CompiledAgentSnapshotSchema = strictObject({
+    definition: CompiledAgentDataSchema,
+    sourceSha256: string2().regex(/^[a-f0-9]{64}$/),
+    bundleSha256: string2().regex(/^[a-f0-9]{64}$/),
+    toolchain: strictObject({
+      sdkVersion: string2().min(1),
+      zodVersion: string2().min(1),
+      bunVersion: string2().min(1)
+    })
+  });
+});
+
+// ../types/src/git-source/lockfile.ts
+import { createHash } from "node:crypto";
+function sourceLockfileInputHash(input) {
+  return createHash("sha256").update(JSON.stringify(input)).digest("hex");
+}
+var SourceLockPackageSchema, SourceLockfileSchema;
+var init_lockfile = __esm(() => {
+  init_zod();
+  init_agent_definition();
+  init_grammar();
+  SourceLockPackageSchema = lazy(() => object({
+    packagePath: SourcePackagePathSchema,
+    requestedRef: SourceVersionRefSchema,
+    resolvedRef: string2().min(1),
+    resolvedTag: string2().min(1).optional(),
+    commit: string2().regex(SOURCE_COMMIT_SHA_PATTERN),
+    dependencies: array(SourceLockPackageSchema),
+    compiledAgent: CompiledAgentSnapshotSchema.optional(),
+    agentRuntimeConfig: record(string2(), unknown()).optional()
+  }));
+  SourceLockfileSchema = object({
+    lockfileVersion: literal(1),
+    eigenpalVersion: string2().min(1),
+    inputHash: string2().min(1),
+    root: SourceLockPackageSchema
+  });
+});
+
 // ../types/src/git-source/secrets.ts
 var SOURCE_SECRETS_FILENAME = "secrets.enc.yaml", SecretNameSchema, Base64LikeSchema, EncryptedSecretValueSchema, SourceSecretEntrySchema, SourceSecretsFileSchema;
 var init_secrets = __esm(() => {
@@ -57237,6 +57272,7 @@ var init_git_source = __esm(() => {
   init_lockfile();
   init_manifests();
   init_secrets();
+  init_agent_definition();
 });
 
 // ../types/src/automation/triggers.ts
@@ -183331,7 +183367,7 @@ import { createRequire as __prettierCreateRequire } from "module";
 import { fileURLToPath as __prettierFileUrlToPath } from "url";
 import { dirname as __prettierDirname } from "path";
 import path102 from "path";
-import * as path12 from "path";
+import * as path13 from "path";
 import * as url from "url";
 import path52 from "path";
 import * as path42 from "path";
@@ -183362,7 +183398,7 @@ import { createRequire as createRequire3 } from "module";
 import { equal, ok, strictEqual } from "assert";
 import path112 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import path13 from "path";
+import path132 from "path";
 import { pathToFileURL as pathToFileURL5 } from "url";
 import path122 from "path";
 import path14 from "path";
@@ -188063,11 +188099,11 @@ async function importPlugin(name, cwd) {
   if (isUrl(name)) {
     return import(name);
   }
-  if (path13.isAbsolute(name)) {
+  if (path132.isAbsolute(name)) {
     return import(pathToFileURL5(name).href);
   }
   try {
-    return await import(pathToFileURL5(path13.resolve(name)).href);
+    return await import(pathToFileURL5(path132.resolve(name)).href);
   } catch {
     return import_from_directory_default(name, cwd);
   }
@@ -188781,7 +188817,7 @@ var require3, __filename2, __dirname2, __create2, __defProp3, __getOwnPropDesc2,
       }
     }
   }
-}, errors_exports, ConfigError, UndefinedParserError, ArgExpansionBailout, create_mockable_default, mockable, mockable_default, import_micromatch, URL_STRING_PREFIX = "file:", isUrlInstance = (value) => value instanceof URL, isUrlString = (value) => typeof value === "string" && value.startsWith(URL_STRING_PREFIX), isUrl = (urlOrPath) => isUrlInstance(urlOrPath) || isUrlString(urlOrPath), toPath = (urlOrPath) => isUrl(urlOrPath) ? url.fileURLToPath(urlOrPath) : urlOrPath, toAbsolutePath = (urlOrPath) => urlOrPath ? path12.resolve(isUrl(urlOrPath) ? url.fileURLToPath(urlOrPath) : urlOrPath) : urlOrPath, partition_default, import_editorconfig, isFile = (stats) => stats?.isFile(), isDirectory = (stats) => stats?.isDirectory(), iterate_directory_up_default, Searcher = class {
+}, errors_exports, ConfigError, UndefinedParserError, ArgExpansionBailout, create_mockable_default, mockable, mockable_default, import_micromatch, URL_STRING_PREFIX = "file:", isUrlInstance = (value) => value instanceof URL, isUrlString = (value) => typeof value === "string" && value.startsWith(URL_STRING_PREFIX), isUrl = (urlOrPath) => isUrlInstance(urlOrPath) || isUrlString(urlOrPath), toPath = (urlOrPath) => isUrl(urlOrPath) ? url.fileURLToPath(urlOrPath) : urlOrPath, toAbsolutePath = (urlOrPath) => urlOrPath ? path13.resolve(isUrl(urlOrPath) ? url.fileURLToPath(urlOrPath) : urlOrPath) : urlOrPath, partition_default, import_editorconfig, isFile = (stats) => stats?.isFile(), isDirectory = (stats) => stats?.isDirectory(), iterate_directory_up_default, Searcher = class {
   #stopDirectory;
   #cache;
   #resultCache = /* @__PURE__ */ new Map;
@@ -207618,363 +207654,9 @@ import path20 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/agents/index.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import path16 from "node:path";
 
-// src/lib/api-paths.ts
-var API_PREFIX = "/v1";
-function apiPath(suffix) {
-  if (suffix === "/v1" || suffix.startsWith("/v1/"))
-    return suffix;
-  if (suffix === "/api/v1" || suffix.startsWith("/api/v1/")) {
-    return `${API_PREFIX}${suffix.slice("/api/v1".length)}`;
-  }
-  const normalized = suffix.startsWith("/") ? suffix : `/${suffix}`;
-  return `${API_PREFIX}${normalized}`;
-}
-function canonicalApiPath(path) {
-  if (path === "/api/v1" || path.startsWith("/api/v1/")) {
-    return `${API_PREFIX}${path.slice("/api/v1".length)}`;
-  }
-  return path;
-}
-function parseBaseUrl(baseUrl) {
-  return new URL(baseUrl.match(/^https?:\/\//i) ? baseUrl : `https://${baseUrl}`);
-}
-function endsWithApiPrefix(basePath) {
-  return basePath === "/api" || basePath.endsWith("/api");
-}
-function endsWithApiV1Prefix(basePath) {
-  return basePath === "/api/v1" || basePath.endsWith("/api/v1");
-}
-function resolveRequestUrl(baseUrl, path) {
-  if (/^https?:\/\//i.test(path))
-    return path;
-  const requestPath = canonicalApiPath(path);
-  const isCanonicalV1 = requestPath === API_PREFIX || requestPath.startsWith(`${API_PREFIX}/`);
-  const base = parseBaseUrl(baseUrl);
-  const basePath = base.pathname.replace(/\/+$/, "");
-  if (isCanonicalV1) {
-    if (endsWithApiV1Prefix(basePath)) {
-      const suffix = requestPath === API_PREFIX ? "" : requestPath.slice(API_PREFIX.length);
-      return `${base.origin}${basePath}${suffix}`;
-    }
-    if (endsWithApiPrefix(basePath)) {
-      return `${base.origin}${basePath}${requestPath}`;
-    }
-    return `${base.origin}${requestPath}`;
-  }
-  if (requestPath.startsWith("/api/") && (endsWithApiPrefix(basePath) || endsWithApiV1Prefix(basePath))) {
-    return `${base.origin}${requestPath}`;
-  }
-  if (!basePath)
-    return `${base.origin}${requestPath}`;
-  return `${base.origin}${basePath}${requestPath}`;
-}
-
-// src/lib/fetch-body.ts
-function isNodeReadableStream(body) {
-  return typeof body.pipe === "function";
-}
-function byteViewToArrayBuffer(view) {
-  if (view.buffer instanceof ArrayBuffer && view.byteOffset === 0 && view.byteLength === view.buffer.byteLength) {
-    return view.buffer;
-  }
-  const copy = new Uint8Array(view.byteLength);
-  copy.set(view);
-  return copy.buffer;
-}
-function toPutBody(body) {
-  if (isNodeReadableStream(body)) {
-    return body;
-  }
-  return byteViewToArrayBuffer(body);
-}
-// package.json
-var package_default = {
-  name: "@eigenpal/cli",
-  version: "0.20.48",
-  description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
-  keywords: [
-    "eigenpal",
-    "cli",
-    "ai",
-    "agent",
-    "workflow",
-    "llm",
-    "evals",
-    "experiments",
-    "document",
-    "extraction",
-    "ocr"
-  ],
-  homepage: "https://github.com/eigenpal/cli#readme",
-  bugs: {
-    url: "https://github.com/eigenpal/cli/issues"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/eigenpal/cli.git"
-  },
-  license: "Apache-2.0",
-  author: "Jedr Blaszyk <jedr@eigenpal.com> (https://eigenpal.com)",
-  type: "module",
-  main: "./src/index.ts",
-  types: "./src/index.ts",
-  bin: {
-    eigenpal: "dist/cli.js"
-  },
-  engines: {
-    node: ">=20"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    dev: "bun src/cli.ts",
-    build: "bun run generate:skill && bun build src/cli.ts --outdir dist --target node --format esm && rm -rf dist/templates dist/skill && cp -R src/templates dist/templates && cp -R src/skill dist/skill && cp src/docs-bundle.json dist/docs-bundle.json",
-    generate: "bun run generate:cli-docs && bun run generate:skill && bun run generate:docs",
-    "generate:check": "bun run generate:cli-docs:check && bun run generate:skill:check && bun run generate:docs:check && bun test scripts/docs-bundle-completeness.test.ts",
-    "generate:docs": "bun scripts/generate-docs-bundle.ts",
-    "generate:docs:check": "bun scripts/generate-docs-bundle.ts --check",
-    "generate:skill": "bun scripts/generate-skill-reference.ts",
-    "generate:skill:check": "bun scripts/generate-skill-reference.ts --check",
-    "generate:cli-docs": "bun scripts/generate-cli-docs.ts",
-    "generate:cli-docs:check": "bun scripts/generate-cli-docs.ts --check",
-    "generate:logo": "bun scripts/render-logo-ascii.ts --cells 20",
-    test: "bun test src/ scripts/",
-    typecheck: "bun check"
-  },
-  dependencies: {
-    "@clack/prompts": "^1.3.0",
-    ajv: "8.20.0",
-    commander: "^14.0.3",
-    fflate: "0.8.3",
-    picocolors: "^1.1.1",
-    yaml: "2.9.1",
-    xlsx: "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
-    zod: "^4.4.3"
-  },
-  devDependencies: {
-    "@eigenpal/common": "workspace:*",
-    "@eigenpal/types": "workspace:*",
-    "@eigenpal/workflow-yaml": "workspace:*",
-    "@t3-oss/env-core": "^0.13.11",
-    typescript: "^7.0.2"
-  },
-  files: [
-    "dist",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ]
-};
-
-// src/lib/telemetry.ts
-var CLI_VERSION = package_default.version === "0.0.0-placeholder" ? "dev" : package_default.version;
-function detectRuntime() {
-  const bun = globalThis.Bun;
-  if (bun?.version)
-    return `bun-${bun.version}`;
-  return `node-${process.versions.node}`;
-}
-function buildCliTelemetryHeaders() {
-  const runtime = detectRuntime();
-  const os = `${process.platform}-${process.arch}`;
-  return {
-    "X-Eigenpal-Sdk": "cli",
-    "X-Eigenpal-Sdk-Version": CLI_VERSION,
-    "X-Eigenpal-Sdk-Runtime": runtime,
-    "X-Eigenpal-Sdk-Os": os,
-    "User-Agent": `eigenpal-cli/${CLI_VERSION} (${runtime}; ${os})`
-  };
-}
-
-// src/lib/client.ts
-class ApiError extends Error {
-  status;
-  body;
-  constructor(status, body) {
-    const msg = typeof body === "object" && body !== null && "error" in body ? body.error : `HTTP ${status}`;
-    super(msg);
-    this.status = status;
-    this.body = body;
-    this.name = "ApiError";
-  }
-}
-
-class HtmlResponseError extends Error {
-  resolvedUrl;
-  constructor(resolvedUrl) {
-    super(`API not reachable at ${resolvedUrl} — got HTML response (likely wrong base URL or API not running)`);
-    this.resolvedUrl = resolvedUrl;
-    this.name = "HtmlResponseError";
-  }
-}
-function assertNotHtml(res, resolvedUrl) {
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.toLowerCase().startsWith("text/html")) {
-    throw new HtmlResponseError(resolvedUrl);
-  }
-}
-
-class ApiClient {
-  baseUrl;
-  apiKey;
-  tenantId;
-  constructor(config) {
-    this.baseUrl = config.baseUrl;
-    this.apiKey = config.apiKey;
-    this.tenantId = config.tenantId;
-  }
-  buildUrl(path) {
-    return resolveRequestUrl(this.baseUrl, path);
-  }
-  headers(extra = {}) {
-    return {
-      ...buildCliTelemetryHeaders(),
-      Authorization: `Bearer ${this.apiKey}`,
-      "X-Eigenpal-Trigger": "cli",
-      ...this.tenantId ? { "x-eigenpal-tenant-id": this.tenantId } : {},
-      ...extra
-    };
-  }
-  async handleResponse(res, resolvedUrl) {
-    if (res.status === 204)
-      return null;
-    assertNotHtml(res, resolvedUrl);
-    const contentType = res.headers.get("content-type") || "";
-    if (!res.ok) {
-      let body;
-      try {
-        body = contentType.includes("json") ? await res.json() : await res.text();
-      } catch {
-        body = `HTTP ${res.status}`;
-      }
-      throw new ApiError(res.status, body);
-    }
-    if (contentType.includes("json")) {
-      return res.json();
-    }
-    return res;
-  }
-  async get(path, params) {
-    let url = this.buildUrl(path);
-    if (params) {
-      const qs = new URLSearchParams(params).toString();
-      if (qs)
-        url += `?${qs}`;
-    }
-    const res = await fetch(url, { headers: this.headers() });
-    return this.handleResponse(res, url);
-  }
-  async post(path, body) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers({ "Content-Type": "application/json" }),
-      body: body !== undefined ? JSON.stringify(body) : undefined
-    });
-    return this.handleResponse(res, url);
-  }
-  async put(path, body) {
-    const url = this.buildUrl(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 putBytes(path, body) {
-    const url = this.buildUrl(path);
-    const stream = isNodeReadableStream(body);
-    const init = {
-      method: "PUT",
-      headers: this.headers({ "Content-Type": "application/octet-stream" }),
-      body,
-      ...stream ? { duplex: "half" } : {}
-    };
-    const res = await fetch(url, init);
-    return this.handleResponse(res, url);
-  }
-  async patch(path, body) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "PATCH",
-      headers: this.headers({ "Content-Type": "application/json" }),
-      body: JSON.stringify(body)
-    });
-    return this.handleResponse(res, url);
-  }
-  async postFormData(path, formData) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers(),
-      body: formData
-    });
-    return this.handleResponse(res, url);
-  }
-  async putFormData(path, formData) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "PUT",
-      headers: this.headers(),
-      body: formData
-    });
-    return this.handleResponse(res, url);
-  }
-  async patchFormData(path, formData) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "PATCH",
-      headers: this.headers(),
-      body: formData
-    });
-    return this.handleResponse(res, url);
-  }
-  async delete(path) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "DELETE",
-      headers: this.headers()
-    });
-    return this.handleResponse(res, url);
-  }
-  async getStream(path) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      headers: this.headers()
-    });
-    assertNotHtml(res, url);
-    if (!res.ok) {
-      throw new ApiError(res.status, `Failed to download: HTTP ${res.status}`);
-    }
-    return res;
-  }
-  async postStream(path, body) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers({ "Content-Type": "application/json" }),
-      body: body !== undefined ? JSON.stringify(body) : undefined
-    });
-    assertNotHtml(res, url);
-    return res;
-  }
-  async postFormDataStream(path, formData) {
-    const url = this.buildUrl(path);
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers(),
-      body: formData
-    });
-    assertNotHtml(res, url);
-    return res;
-  }
-}
-
 // ../../node_modules/@t3-oss/env-core/dist/standard.js
 function ensureSynchronous(value, message) {
   if (value instanceof Promise)
@@ -208381,6 +208063,360 @@ function requireApiKey(config) {
   return config.apiKey;
 }
 
+// src/lib/api-paths.ts
+var API_PREFIX = "/v1";
+function apiPath(suffix) {
+  if (suffix === "/v1" || suffix.startsWith("/v1/"))
+    return suffix;
+  if (suffix === "/api/v1" || suffix.startsWith("/api/v1/")) {
+    return `${API_PREFIX}${suffix.slice("/api/v1".length)}`;
+  }
+  const normalized = suffix.startsWith("/") ? suffix : `/${suffix}`;
+  return `${API_PREFIX}${normalized}`;
+}
+function canonicalApiPath(path) {
+  if (path === "/api/v1" || path.startsWith("/api/v1/")) {
+    return `${API_PREFIX}${path.slice("/api/v1".length)}`;
+  }
+  return path;
+}
+function parseBaseUrl(baseUrl) {
+  return new URL(baseUrl.match(/^https?:\/\//i) ? baseUrl : `https://${baseUrl}`);
+}
+function endsWithApiPrefix(basePath) {
+  return basePath === "/api" || basePath.endsWith("/api");
+}
+function endsWithApiV1Prefix(basePath) {
+  return basePath === "/api/v1" || basePath.endsWith("/api/v1");
+}
+function resolveRequestUrl(baseUrl, path) {
+  if (/^https?:\/\//i.test(path))
+    return path;
+  const requestPath = canonicalApiPath(path);
+  const isCanonicalV1 = requestPath === API_PREFIX || requestPath.startsWith(`${API_PREFIX}/`);
+  const base = parseBaseUrl(baseUrl);
+  const basePath = base.pathname.replace(/\/+$/, "");
+  if (isCanonicalV1) {
+    if (endsWithApiV1Prefix(basePath)) {
+      const suffix = requestPath === API_PREFIX ? "" : requestPath.slice(API_PREFIX.length);
+      return `${base.origin}${basePath}${suffix}`;
+    }
+    if (endsWithApiPrefix(basePath)) {
+      return `${base.origin}${basePath}${requestPath}`;
+    }
+    return `${base.origin}${requestPath}`;
+  }
+  if (requestPath.startsWith("/api/") && (endsWithApiPrefix(basePath) || endsWithApiV1Prefix(basePath))) {
+    return `${base.origin}${requestPath}`;
+  }
+  if (!basePath)
+    return `${base.origin}${requestPath}`;
+  return `${base.origin}${basePath}${requestPath}`;
+}
+
+// src/lib/fetch-body.ts
+function isNodeReadableStream(body) {
+  return typeof body.pipe === "function";
+}
+function byteViewToArrayBuffer(view) {
+  if (view.buffer instanceof ArrayBuffer && view.byteOffset === 0 && view.byteLength === view.buffer.byteLength) {
+    return view.buffer;
+  }
+  const copy = new Uint8Array(view.byteLength);
+  copy.set(view);
+  return copy.buffer;
+}
+function toPutBody(body) {
+  if (isNodeReadableStream(body)) {
+    return body;
+  }
+  return byteViewToArrayBuffer(body);
+}
+// package.json
+var package_default = {
+  name: "@eigenpal/cli",
+  version: "0.20.50",
+  description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
+  keywords: [
+    "eigenpal",
+    "cli",
+    "ai",
+    "agent",
+    "workflow",
+    "llm",
+    "evals",
+    "experiments",
+    "document",
+    "extraction",
+    "ocr"
+  ],
+  homepage: "https://github.com/eigenpal/cli#readme",
+  bugs: {
+    url: "https://github.com/eigenpal/cli/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/eigenpal/cli.git"
+  },
+  license: "Apache-2.0",
+  author: "Jedr Blaszyk <jedr@eigenpal.com> (https://eigenpal.com)",
+  type: "module",
+  main: "./src/index.ts",
+  types: "./src/index.ts",
+  bin: {
+    eigenpal: "dist/cli.js"
+  },
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    dev: "bun src/cli.ts",
+    build: "bun run generate:skill && bun build src/cli.ts --outdir dist --target node --format esm && rm -rf dist/templates dist/skill && cp -R src/templates dist/templates && cp -R src/skill dist/skill && cp src/docs-bundle.json dist/docs-bundle.json",
+    generate: "bun run generate:cli-docs && bun run generate:skill && bun run generate:docs",
+    "generate:check": "bun run generate:cli-docs:check && bun run generate:skill:check && bun run generate:docs:check && bun test scripts/docs-bundle-completeness.test.ts",
+    "generate:docs": "bun scripts/generate-docs-bundle.ts",
+    "generate:docs:check": "bun scripts/generate-docs-bundle.ts --check",
+    "generate:skill": "bun scripts/generate-skill-reference.ts",
+    "generate:skill:check": "bun scripts/generate-skill-reference.ts --check",
+    "generate:cli-docs": "bun scripts/generate-cli-docs.ts",
+    "generate:cli-docs:check": "bun scripts/generate-cli-docs.ts --check",
+    "generate:logo": "bun scripts/render-logo-ascii.ts --cells 20",
+    test: "bun test src/ scripts/",
+    typecheck: "bun check"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.3.0",
+    ajv: "8.20.0",
+    commander: "^14.0.3",
+    fflate: "0.8.3",
+    picocolors: "^1.1.1",
+    yaml: "2.9.1",
+    xlsx: "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@eigenpal/common": "workspace:*",
+    "@eigenpal/types": "workspace:*",
+    "@eigenpal/workflow-yaml": "workspace:*",
+    "@t3-oss/env-core": "^0.13.11",
+    typescript: "^7.0.2"
+  },
+  files: [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ]
+};
+
+// src/lib/telemetry.ts
+var CLI_VERSION = package_default.version === "0.0.0-placeholder" ? "dev" : package_default.version;
+function detectRuntime() {
+  const bun = globalThis.Bun;
+  if (bun?.version)
+    return `bun-${bun.version}`;
+  return `node-${process.versions.node}`;
+}
+function buildCliTelemetryHeaders() {
+  const runtime = detectRuntime();
+  const os = `${process.platform}-${process.arch}`;
+  return {
+    "X-Eigenpal-Sdk": "cli",
+    "X-Eigenpal-Sdk-Version": CLI_VERSION,
+    "X-Eigenpal-Sdk-Runtime": runtime,
+    "X-Eigenpal-Sdk-Os": os,
+    "User-Agent": `eigenpal-cli/${CLI_VERSION} (${runtime}; ${os})`
+  };
+}
+
+// src/lib/client.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    const msg = typeof body === "object" && body !== null && "error" in body ? body.error : `HTTP ${status}`;
+    super(msg);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+}
+
+class HtmlResponseError extends Error {
+  resolvedUrl;
+  constructor(resolvedUrl) {
+    super(`API not reachable at ${resolvedUrl} — got HTML response (likely wrong base URL or API not running)`);
+    this.resolvedUrl = resolvedUrl;
+    this.name = "HtmlResponseError";
+  }
+}
+function assertNotHtml(res, resolvedUrl) {
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.toLowerCase().startsWith("text/html")) {
+    throw new HtmlResponseError(resolvedUrl);
+  }
+}
+
+class ApiClient {
+  baseUrl;
+  apiKey;
+  tenantId;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.apiKey = config.apiKey;
+    this.tenantId = config.tenantId;
+  }
+  buildUrl(path) {
+    return resolveRequestUrl(this.baseUrl, path);
+  }
+  headers(extra = {}) {
+    return {
+      ...buildCliTelemetryHeaders(),
+      Authorization: `Bearer ${this.apiKey}`,
+      "X-Eigenpal-Trigger": "cli",
+      ...this.tenantId ? { "x-eigenpal-tenant-id": this.tenantId } : {},
+      ...extra
+    };
+  }
+  async handleResponse(res, resolvedUrl) {
+    if (res.status === 204)
+      return null;
+    assertNotHtml(res, resolvedUrl);
+    const contentType = res.headers.get("content-type") || "";
+    if (!res.ok) {
+      let body;
+      try {
+        body = contentType.includes("json") ? await res.json() : await res.text();
+      } catch {
+        body = `HTTP ${res.status}`;
+      }
+      throw new ApiError(res.status, body);
+    }
+    if (contentType.includes("json")) {
+      return res.json();
+    }
+    return res;
+  }
+  async get(path, params) {
+    let url = this.buildUrl(path);
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      if (qs)
+        url += `?${qs}`;
+    }
+    const res = await fetch(url, { headers: this.headers() });
+    return this.handleResponse(res, url);
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    return this.handleResponse(res, url);
+  }
+  async put(path, body) {
+    const url = this.buildUrl(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 putBytes(path, body) {
+    const url = this.buildUrl(path);
+    const stream = isNodeReadableStream(body);
+    const init = {
+      method: "PUT",
+      headers: this.headers({ "Content-Type": "application/octet-stream" }),
+      body,
+      ...stream ? { duplex: "half" } : {}
+    };
+    const res = await fetch(url, init);
+    return this.handleResponse(res, url);
+  }
+  async patch(path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "PATCH",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return this.handleResponse(res, url);
+  }
+  async postFormData(path, formData) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: formData
+    });
+    return this.handleResponse(res, url);
+  }
+  async putFormData(path, formData) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: this.headers(),
+      body: formData
+    });
+    return this.handleResponse(res, url);
+  }
+  async patchFormData(path, formData) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "PATCH",
+      headers: this.headers(),
+      body: formData
+    });
+    return this.handleResponse(res, url);
+  }
+  async delete(path) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    return this.handleResponse(res, url);
+  }
+  async getStream(path) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      headers: this.headers()
+    });
+    assertNotHtml(res, url);
+    if (!res.ok) {
+      throw new ApiError(res.status, `Failed to download: HTTP ${res.status}`);
+    }
+    return res;
+  }
+  async postStream(path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    assertNotHtml(res, url);
+    return res;
+  }
+  async postFormDataStream(path, formData) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: formData
+    });
+    assertNotHtml(res, url);
+    return res;
+  }
+}
+
 // src/lib/format-error.ts
 var CONNECTION_FAILURE_TOKENS = [
   "ECONNREFUSED",
@@ -208535,15 +208571,56 @@ async function requireTypedConfirmation(opts) {
 init_src();
 init_zod();
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
+
+// src/commands/git/agent-definition.ts
+init_src();
+import { existsSync as existsSync2, lstatSync, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import path from "node:path";
+function captureAgentSource(root) {
+  for (const name of ["eigenpal.yaml", "eigenpal.yml", "input-schema.json", "output-schema.json"])
+    if (existsSync2(path.join(root, name)))
+      throw new Error("Agent package mixes TypeScript and legacy definition files");
+  const files = {};
+  let bytes = 0;
+  const visit = (directory) => {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if ([".git", ".eigenpal", "eigenpal_modules", "node_modules"].includes(entry.name))
+        continue;
+      const absolute = path.join(directory, entry.name);
+      const relative = path.relative(root, absolute).split(path.sep).join("/");
+      const stat = lstatSync(absolute);
+      if (stat.isDirectory()) {
+        visit(absolute);
+        continue;
+      }
+      if (!/\.(ts|js)$/.test(relative))
+        continue;
+      if (!stat.isFile() || !/^[a-zA-Z0-9_./-]+\.(ts|js)$/.test(relative))
+        throw new Error("Agent modules must be regular package-local files");
+      bytes += stat.size + Buffer.byteLength(relative);
+      if (Object.keys(files).length >= 32 || bytes > 256 * 1024)
+        throw new Error("Agent source exceeds the compilation limit");
+      files[relative] = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readFileSync2(absolute));
+    }
+  };
+  visit(root);
+  if (!Object.hasOwn(files, "agent.ts"))
+    throw new Error("Agent entry must be a regular agent.ts file");
+  return { entry: "agent.ts", files };
+}
+async function compileLocalAgent(root, config) {
+  const source = captureAgentSource(root);
+  return CompiledAgentSnapshotSchema.parse(await new ApiClient(config ?? resolveConfig({})).post("/v1/source/agent-definition", source));
+}
 
 // src/commands/git/init.ts
 init_src();
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import path3 from "node:path";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -208591,24 +208668,160 @@ var $parseDocument = publicApi.parseDocument;
 var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
+// ../../node_modules/zod/package.json
+var package_default2 = {
+  name: "zod",
+  version: "4.4.3",
+  type: "module",
+  license: "MIT",
+  author: "Colin McDonnell <zod@colinhacks.com>",
+  description: "TypeScript-first schema declaration and validation library with static type inference",
+  homepage: "https://zod.dev",
+  llms: "https://zod.dev/llms.txt",
+  llmsFull: "https://zod.dev/llms-full.txt",
+  mcpServer: "https://mcp.inkeep.com/zod/mcp",
+  funding: "https://github.com/sponsors/colinhacks",
+  sideEffects: false,
+  files: [
+    "src",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.d.cts",
+    "**/package.json"
+  ],
+  keywords: [
+    "typescript",
+    "schema",
+    "validation",
+    "type",
+    "inference"
+  ],
+  main: "./index.cjs",
+  types: "./index.d.cts",
+  module: "./index.js",
+  zshy: {
+    exports: {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts",
+      "./mini": "./src/mini/index.ts",
+      "./locales": "./src/locales/index.ts",
+      "./v3": "./src/v3/index.ts",
+      "./v4": "./src/v4/index.ts",
+      "./v4-mini": "./src/v4-mini/index.ts",
+      "./v4/mini": "./src/v4/mini/index.ts",
+      "./v4/core": "./src/v4/core/index.ts",
+      "./v4/locales": "./src/v4/locales/index.ts",
+      "./v4/locales/*": "./src/v4/locales/*"
+    },
+    conditions: {
+      "@zod/source": "src"
+    }
+  },
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      "@zod/source": "./src/index.ts",
+      types: "./index.d.cts",
+      import: "./index.js",
+      require: "./index.cjs"
+    },
+    "./mini": {
+      "@zod/source": "./src/mini/index.ts",
+      types: "./mini/index.d.cts",
+      import: "./mini/index.js",
+      require: "./mini/index.cjs"
+    },
+    "./locales": {
+      "@zod/source": "./src/locales/index.ts",
+      types: "./locales/index.d.cts",
+      import: "./locales/index.js",
+      require: "./locales/index.cjs"
+    },
+    "./v3": {
+      "@zod/source": "./src/v3/index.ts",
+      types: "./v3/index.d.cts",
+      import: "./v3/index.js",
+      require: "./v3/index.cjs"
+    },
+    "./v4": {
+      "@zod/source": "./src/v4/index.ts",
+      types: "./v4/index.d.cts",
+      import: "./v4/index.js",
+      require: "./v4/index.cjs"
+    },
+    "./v4-mini": {
+      "@zod/source": "./src/v4-mini/index.ts",
+      types: "./v4-mini/index.d.cts",
+      import: "./v4-mini/index.js",
+      require: "./v4-mini/index.cjs"
+    },
+    "./v4/mini": {
+      "@zod/source": "./src/v4/mini/index.ts",
+      types: "./v4/mini/index.d.cts",
+      import: "./v4/mini/index.js",
+      require: "./v4/mini/index.cjs"
+    },
+    "./v4/core": {
+      "@zod/source": "./src/v4/core/index.ts",
+      types: "./v4/core/index.d.cts",
+      import: "./v4/core/index.js",
+      require: "./v4/core/index.cjs"
+    },
+    "./v4/locales": {
+      "@zod/source": "./src/v4/locales/index.ts",
+      types: "./v4/locales/index.d.cts",
+      import: "./v4/locales/index.js",
+      require: "./v4/locales/index.cjs"
+    },
+    "./v4/locales/*": {
+      "@zod/source": "./src/v4/locales/*",
+      types: "./v4/locales/*",
+      import: "./v4/locales/*",
+      require: "./v4/locales/*"
+    }
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/colinhacks/zod.git"
+  },
+  bugs: {
+    url: "https://github.com/colinhacks/zod/issues"
+  },
+  support: {
+    backing: {
+      "npm-funding": true
+    }
+  },
+  scripts: {
+    clean: "git clean -xdf . -e node_modules",
+    build: "zshy --project tsconfig.build.json",
+    postbuild: "tsx ../../scripts/write-stub-package-jsons.ts && pnpm biome check --write .",
+    "test:watch": "pnpm vitest",
+    test: "pnpm vitest run",
+    prepublishOnly: "tsx ../../scripts/check-versions.ts"
+  }
+};
 
 // src/commands/git/source-state.ts
 init_src();
 import { spawnSync as spawnSync2 } from "node:child_process";
 import {
-  existsSync as existsSync2,
-  readdirSync,
-  readFileSync as readFileSync3,
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
   realpathSync as realpathSync2,
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 
 // src/commands/git/source-git.ts
 init_zod();
 import { spawnSync } from "node:child_process";
-import { readFileSync as readFileSync2, realpathSync } from "node:fs";
+import { readFileSync as readFileSync3, realpathSync } from "node:fs";
 var SourceRepositorySchema = object({
   gitRepositoryPath: string2(),
   remoteUrl: string2().url()
@@ -208805,7 +209018,7 @@ function runSourceGitCredentialHelper(operation) {
   const remoteUrl = gitOutput(["config", "--get", "eigenpal.gitRemoteUrl"], gitRoot) ?? gitOutput(["remote", "get-url", "origin"], gitRoot);
   if (!remoteUrl || !isEigenpalGitRemote(remoteUrl))
     return;
-  const fields = parseCredentialHelperInput(readFileSync2(0, "utf8"));
+  const fields = parseCredentialHelperInput(readFileSync3(0, "utf8"));
   if (!credentialRequestMatchesRemote(fields, normalizeGitRemoteUrl(remoteUrl)))
     return;
   const pinnedProfile = gitOutput(["config", "--get", "eigenpal.profile"], gitRoot);
@@ -208856,7 +209069,7 @@ function gitOutput2(args, cwd, config, bootstrapRemoteUrl) {
   return result.stdout.trim();
 }
 function sourcePathFromPackageRoot(gitRoot, packageRoot) {
-  const relativePath = path.relative(gitRoot, packageRoot).replace(/\\/g, "/");
+  const relativePath = path2.relative(gitRoot, packageRoot).replace(/\\/g, "/");
   const result = SourcePackagePathSchema.safeParse(relativePath);
   return result.success ? result.data : null;
 }
@@ -208869,20 +209082,20 @@ function isOrganizationSourceGitRoot(gitRoot) {
   return Boolean(gitOutput2(["remote", "get-url", "origin"], gitRoot)?.match(/\/orgs\/[^/]+\.git$/));
 }
 function findNearestPackageRoot(startDir, gitRoot) {
-  let current = path.resolve(startDir);
+  let current = path2.resolve(startDir);
   while (true) {
-    if (existsSync2(path.join(current, "eigenpal.yaml")))
+    if (existsSync3(path2.join(current, "eigenpal.yaml")) || existsSync3(path2.join(current, "agent.ts")))
       return current;
     if (gitRoot && current === gitRoot)
       return null;
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current)
       return null;
     current = parent;
   }
 }
 function resolveGitSourceContext(opts = {}) {
-  const startDir = realpathSync2(path.resolve(opts.dir ?? process.cwd()));
+  const startDir = realpathSync2(path2.resolve(opts.dir ?? process.cwd()));
   const gitRoot = resolveGitRoot2(startDir);
   const packageRoot = findNearestPackageRoot(startDir, gitRoot);
   const resolvedPackageRoot = packageRoot ? realpathSync2(packageRoot) : null;
@@ -208895,11 +209108,11 @@ function resolveGitSourceContext(opts = {}) {
 function listRelativeFiles(dir) {
   const files = [];
   const visit = (current) => {
-    for (const entry of readdirSync(current)) {
+    for (const entry of readdirSync2(current)) {
       if (entry === ".git" || entry === "eigenpal_modules" || entry === ".eigenpal")
         continue;
-      const fullPath = path.join(current, entry);
-      const rel = path.relative(dir, fullPath).replace(/\\/g, "/");
+      const fullPath = path2.join(current, entry);
+      const rel = path2.relative(dir, fullPath).replace(/\\/g, "/");
       if (statSync(fullPath).isDirectory())
         visit(fullPath);
       else
@@ -208910,20 +209123,22 @@ function listRelativeFiles(dir) {
   return files;
 }
 function readYamlFile(filePath) {
-  return exports_dist.parse(readFileSync3(filePath, "utf8"));
+  return exports_dist.parse(readFileSync4(filePath, "utf8"));
 }
 function writeYamlFile(filePath, value) {
   writeFileSync2(filePath, exports_dist.stringify(value));
 }
 function packageManifestExists(gitRoot, packagePath) {
-  return existsSync2(path.join(gitRoot, packagePath, "eigenpal.yaml"));
+  return existsSync3(path2.join(gitRoot, packagePath, "eigenpal.yaml")) || packagePath.startsWith("agents/") && existsSync3(path2.join(gitRoot, packagePath, "agent.ts"));
 }
 function releaseTagExists(gitRoot, packagePath, version) {
   const tag = formatReleaseTag(pathToDottedPackageName(packagePath), version);
   return gitOutput2(["tag", "--list", tag], gitRoot) === tag;
 }
-function readPackageManifest(packageRoot) {
-  return SourcePackageManifestSchema.parse(readYamlFile(path.join(packageRoot, "eigenpal.yaml")));
+async function readPackageManifest(packageRoot, config) {
+  if (resolveGitSourceContext({ dir: packageRoot }).packagePath?.startsWith("agents/") && existsSync3(path2.join(packageRoot, "agent.ts")))
+    return SourcePackageManifestSchema.parse((await compileLocalAgent(packageRoot, config)).definition.manifest);
+  return SourcePackageManifestSchema.parse(readYamlFile(path2.join(packageRoot, "eigenpal.yaml")));
 }
 function requirePackageContext(opts = {}) {
   const context = resolveGitSourceContext(opts);
@@ -208952,8 +209167,8 @@ function validatePackageReferences(input) {
   const evaluatorItems = "evaluators" in input.manifest && input.manifest.evaluators && typeof input.manifest.evaluators === "object" && !Array.isArray(input.manifest.evaluators) && "items" in input.manifest.evaluators ? input.manifest.evaluators.items : [];
   for (const item of evaluatorItems) {
     if (item.use.startsWith("./")) {
-      const evaluatorPath = path.normalize(path.join(input.packageRoot, item.use));
-      if (!evaluatorPath.startsWith(`${input.packageRoot}${path.sep}`) || !existsSync2(evaluatorPath)) {
+      const evaluatorPath = path2.normalize(path2.join(input.packageRoot, item.use));
+      if (!evaluatorPath.startsWith(`${input.packageRoot}${path2.sep}`) || !existsSync3(evaluatorPath)) {
         errors.push(`Local evaluator ${item.use} does not exist.`);
       }
       continue;
@@ -208971,21 +209186,27 @@ function validatePackageReferences(input) {
   }
   return errors;
 }
-function validatePackage(dir) {
+async function validatePackage(dir, config) {
   const context = resolveGitSourceContext({ dir });
   const errors = [];
-  const manifestPath = context.packageRoot ? path.join(context.packageRoot, "eigenpal.yaml") : null;
+  const manifestPath = context.packageRoot ? path2.join(context.packageRoot, "eigenpal.yaml") : null;
   let parsedManifest = null;
   if (!context.gitRoot)
     errors.push("Not inside a Git repository.");
   if (!context.packageRoot || !manifestPath)
     errors.push("No package eigenpal.yaml found.");
-  if (context.packageRoot && existsSync2(path.join(context.packageRoot, "eigenpal.yml"))) {
+  if (context.packageRoot && existsSync3(path2.join(context.packageRoot, "eigenpal.yml"))) {
     errors.push("Use eigenpal.yaml; eigenpal.yml package manifests are not supported.");
   }
   if (!context.packagePath)
     errors.push("Package must live under agents/, workflows/, resources/, or evaluators/.");
-  if (manifestPath && existsSync2(manifestPath)) {
+  if (context.packagePath?.startsWith("agents/") && context.packageRoot && existsSync3(path2.join(context.packageRoot, "agent.ts"))) {
+    try {
+      parsedManifest = await readPackageManifest(context.packageRoot, config);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : "Invalid TypeScript definition");
+    }
+  } else if (manifestPath && existsSync3(manifestPath)) {
     const filename = SourceManifestFilenameSchema.safeParse(manifestPath);
     if (!filename.success)
       errors.push(filename.error.issues.map((issue) => issue.message).join("; "));
@@ -208996,8 +209217,8 @@ function validatePackage(dir) {
       parsedManifest = manifest.data;
   }
   if (context.packageRoot) {
-    const secretsPath = path.join(context.packageRoot, SOURCE_SECRETS_FILENAME);
-    if (existsSync2(secretsPath)) {
+    const secretsPath = path2.join(context.packageRoot, SOURCE_SECRETS_FILENAME);
+    if (existsSync3(secretsPath)) {
       const secrets = SourceSecretsFileSchema.safeParse(readYamlFile(secretsPath));
       if (!secrets.success)
         errors.push(secrets.error.issues.map((issue) => issue.message).join("; "));
@@ -209020,8 +209241,8 @@ function validatePackage(dir) {
   return { valid: errors.length === 0, errors, packagePath: context.packagePath ?? undefined };
 }
 function readRootManifest(gitRoot) {
-  const manifestPath = path.join(gitRoot, "eigenpal.yaml");
-  if (!existsSync2(manifestPath))
+  const manifestPath = path2.join(gitRoot, "eigenpal.yaml");
+  if (!existsSync3(manifestPath))
     return { ok: false, error: "Root eigenpal.yaml is missing." };
   const parsed = RootSourceManifestSchema.safeParse(readYamlFile(manifestPath));
   if (!parsed.success)
@@ -209129,7 +209350,7 @@ async function doctor(opts) {
         detail: repoMajor === "1" ? `compatible ${root.version}` : `incompatible ${root.version}; run repository upgrade first`
       });
     }
-    const gitignore = existsSync2(path.join(context.gitRoot, ".gitignore")) ? readFileSync3(path.join(context.gitRoot, ".gitignore"), "utf8") : "";
+    const gitignore = existsSync3(path2.join(context.gitRoot, ".gitignore")) ? readFileSync4(path2.join(context.gitRoot, ".gitignore"), "utf8") : "";
     for (const ignored of [".eigenpal/", "eigenpal_modules/"]) {
       checks.push({
         check: `ignore ${ignored}`,
@@ -209139,7 +209360,7 @@ async function doctor(opts) {
     }
     checks.push({
       check: "unsupported manifest",
-      status: existsSync2(path.join(context.gitRoot, "eigenpal.yml")) ? "fail" : "pass",
+      status: existsSync3(path2.join(context.gitRoot, "eigenpal.yml")) ? "fail" : "pass",
       detail: "root eigenpal.yml must not exist"
     });
     const remoteUrl = gitOutput2(["remote", "get-url", "origin"], context.gitRoot);
@@ -209170,7 +209391,7 @@ async function doctor(opts) {
     }
   }
   if (context.packageRoot && context.packageRoot !== context.gitRoot) {
-    const result = validatePackage(context.packageRoot);
+    const result = await validatePackage(context.packageRoot, resolveConfig(opts));
     checks.push({
       check: "package structure",
       status: result.valid ? "pass" : "fail",
@@ -209188,38 +209409,39 @@ async function doctor(opts) {
   if (checks.some((check) => check.status === "fail"))
     process.exit(1);
 }
-function validateSourcePackage(dir) {
+async function validateSourcePackage(dir, config) {
   const context = resolveGitSourceContext({ dir });
   if (context.gitRoot)
     checkRepoVersion(context.gitRoot, false);
-  return validatePackage(dir);
+  return await validatePackage(dir, config);
 }
-function packageStatus(opts) {
+async function packageStatus(opts) {
   const context = resolveGitSourceContext(opts);
   if (context.gitRoot)
     checkRepoVersion(context.gitRoot, false);
   const isRepoRootStatus = context.gitRoot && context.packageRoot && context.gitRoot === context.packageRoot;
-  const validation = context.packageRoot && !isRepoRootStatus ? validatePackage(context.packageRoot) : null;
+  const validation = context.packageRoot && !isRepoRootStatus ? await validatePackage(context.packageRoot, resolveConfig(opts)) : null;
   const gitStatusLines = context.gitRoot ? readGitStatusLines(context.gitRoot) : [];
   const branch = context.gitRoot ? currentBranchOrNull(context.gitRoot) : null;
   const upstream = context.gitRoot ? gitOutput2(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], context.gitRoot) : null;
   const head = context.gitRoot ? gitOutput2(["rev-parse", "HEAD"], context.gitRoot) : null;
   const aheadOfMain = context.gitRoot ? countAheadOfMain(context.gitRoot) : null;
   const dirtyPackages = context.gitRoot ? dirtyPackagePaths(context.gitRoot) : [];
-  const packages = dirtyPackages.map((packagePath) => {
-    const packageValidation = validatePackage(path.join(context.gitRoot, packagePath));
-    return {
+  const packages = [];
+  for (const packagePath of dirtyPackages) {
+    const packageValidation = await validatePackage(path2.join(context.gitRoot, packagePath), resolveConfig(opts));
+    packages.push({
       packagePath,
       clean: false,
       valid: packageValidation.valid,
       errors: packageValidation.errors
-    };
-  });
+    });
+  }
   if (context.gitRoot && context.packagePath && !packages.some((item) => item.packagePath === context.packagePath)) {
     packages.push({
       packagePath: context.packagePath,
       clean: readGitStatusLines(context.gitRoot, [context.packagePath]).length === 0,
-      valid: validation?.valid ?? validatePackage(context.packageRoot ?? opts.dir ?? process.cwd()).valid,
+      valid: validation?.valid ?? (await validatePackage(context.packageRoot ?? opts.dir ?? process.cwd(), resolveConfig(opts))).valid,
       errors: validation?.errors ?? []
     });
   }
@@ -209248,11 +209470,11 @@ function packageStatus(opts) {
     ]));
   }
 }
-function deps(opts) {
+async function deps(opts) {
   const context = resolveGitSourceContext(opts);
   if (!context.packageRoot)
     throw new Error("No package eigenpal.yaml found.");
-  const manifest = SourcePackageManifestSchema.parse(readYamlFile(path.join(context.packageRoot, "eigenpal.yaml")));
+  const manifest = await readPackageManifest(context.packageRoot, resolveConfig(opts));
   const rows = Object.entries(manifest.dependencies ?? {}).map(([name, version]) => ({
     name,
     version
@@ -209309,7 +209531,7 @@ function dirtyPackagePaths(gitRoot) {
     const parts = file.split("/");
     for (let index = parts.length;index >= 2; index -= 1) {
       const candidate = parts.slice(0, index).join("/");
-      if (SourcePackagePathSchema.safeParse(candidate).success && existsSync2(path.join(gitRoot, candidate, "eigenpal.yaml"))) {
+      if (SourcePackagePathSchema.safeParse(candidate).success && packageManifestExists(gitRoot, candidate)) {
         packagePaths.add(candidate);
         break;
       }
@@ -209318,7 +209540,12 @@ function dirtyPackagePaths(gitRoot) {
   return [...packagePaths].sort();
 }
 function dirtyRootFiles(gitRoot) {
-  return readGitStatusLines(gitRoot, ["eigenpal.yaml", ".gitignore"]).map(statusPath).filter((file) => file === "eigenpal.yaml" || file === ".gitignore");
+  return readGitStatusLines(gitRoot, [
+    "eigenpal.yaml",
+    ".gitignore",
+    "package.json",
+    "package-lock.json"
+  ]).map(statusPath).filter((file) => ["eigenpal.yaml", ".gitignore", "package.json", "package-lock.json"].includes(file));
 }
 function hasDirtySharedResources(gitRoot) {
   return readGitStatusLines(gitRoot, ["resources"]).length > 0;
@@ -209337,7 +209564,7 @@ async function commitSourceChanges(input) {
     throw new Error("Commit requires -m <message> when source changes are dirty.");
   }
   for (const packagePath of packagePaths) {
-    const validation = validatePackage(path.join(input.context.gitRoot, packagePath));
+    const validation = await validatePackage(path2.join(input.context.gitRoot, packagePath), input.config);
     if (!validation.valid) {
       throw new Error(`Package validation failed for ${packagePath}: ${validation.errors.join("; ")}`);
     }
@@ -209384,39 +209611,44 @@ function writePackageScaffold(packageRoot, packagePath, name) {
   const [root, resourceKind] = packagePath.split("/");
   mkdirSync2(packageRoot, { recursive: true });
   const title = name.trim();
-  writeFileSync3(path2.join(packageRoot, "eigenpal.yaml"), exports_dist.stringify({ schemaVersion: 1, name: title || path2.basename(packagePath) }));
   if (root === "agents")
-    writeFileSync3(path2.join(packageRoot, "AGENT.md"), `# ${title}
+    writeFileSync3(path3.join(packageRoot, "agent.ts"), `import {createAgent} from '@eigenpal/automations';
+export default createAgent(${JSON.stringify({ name: title || path3.basename(packagePath) }, null, 2)});
+`);
+  else
+    writeFileSync3(path3.join(packageRoot, "eigenpal.yaml"), exports_dist.stringify({ schemaVersion: 1, name: title || path3.basename(packagePath) }));
+  if (root === "agents")
+    writeFileSync3(path3.join(packageRoot, "AGENT.md"), `# ${title}
 
 `);
   if (root === "evaluators") {
-    writeFileSync3(path2.join(packageRoot, "evaluator.yaml"), exports_dist.stringify({ schemaVersion: 1, type: "exact-diff", config: {} }));
+    writeFileSync3(path3.join(packageRoot, "evaluator.yaml"), exports_dist.stringify({ schemaVersion: 1, type: "exact-diff", config: {} }));
   }
   if (root === "resources" && resourceKind === "skills") {
-    writeFileSync3(path2.join(packageRoot, "SKILL.md"), `# ${title}
+    writeFileSync3(path3.join(packageRoot, "SKILL.md"), `# ${title}
 
 `);
   }
   if (root === "resources" && (resourceKind === "rules" || resourceKind === "knowledge")) {
-    writeFileSync3(path2.join(packageRoot, "README.md"), `# ${title}
+    writeFileSync3(path3.join(packageRoot, "README.md"), `# ${title}
 
 `);
   }
 }
-function initPackage(name, opts) {
-  const startDir = path2.resolve(opts.dir ?? process.cwd());
+async function initPackage(name, opts) {
+  const startDir = path3.resolve(opts.dir ?? process.cwd());
   const gitRoot = resolveGitRoot2(startDir) ?? startDir;
   mkdirSync2(gitRoot, { recursive: true });
-  if (!existsSync3(path2.join(gitRoot, ".git")))
+  if (!existsSync4(path3.join(gitRoot, ".git")))
     runGit(["init", "-b", "main", gitRoot]);
-  if (!existsSync3(path2.join(gitRoot, "eigenpal.yaml"))) {
-    writeFileSync3(path2.join(gitRoot, "eigenpal.yaml"), `schemaVersion: 1
+  if (!existsSync4(path3.join(gitRoot, "eigenpal.yaml"))) {
+    writeFileSync3(path3.join(gitRoot, "eigenpal.yaml"), `schemaVersion: 1
 eigenpalVersion: 1.0.0
 `);
   }
-  const gitignorePath = path2.join(gitRoot, ".gitignore");
-  const gitignore = existsSync3(gitignorePath) ? readFileSync4(gitignorePath, "utf8") : "";
-  const additions = [".eigenpal/", "eigenpal_modules/"].filter((entry) => !gitignore.includes(entry));
+  const gitignorePath = path3.join(gitRoot, ".gitignore");
+  const gitignore = existsSync4(gitignorePath) ? readFileSync5(gitignorePath, "utf8") : "";
+  const additions = [".eigenpal/", "eigenpal_modules/", "node_modules/"].filter((entry) => !gitignore.includes(entry));
   if (additions.length > 0)
     writeFileSync3(gitignorePath, `${gitignore}${gitignore.endsWith(`
 `) || !gitignore ? "" : `
@@ -209424,10 +209656,25 @@ eigenpalVersion: 1.0.0
 `)}
 `);
   const packagePath = packagePathForTemplate(opts.template, name);
-  const packageRoot = path2.join(gitRoot, packagePath);
-  if (existsSync3(packageRoot))
+  const packageRoot = path3.join(gitRoot, packagePath);
+  if (existsSync4(packageRoot))
     throw new Error(`Package already exists: ${packagePath}`);
   writePackageScaffold(packageRoot, packagePath, name);
+  if (opts.template === "agent") {
+    const toolchain = { sdkVersion: CLI_VERSION, zodVersion: package_default2.version };
+    const file = path3.join(gitRoot, "package.json");
+    const current = existsSync4(file) ? JSON.parse(readFileSync5(file, "utf8")) : { private: true, type: "module" };
+    const additions = {};
+    for (const [name, version] of Object.entries({
+      "@eigenpal/automations": toolchain.sdkVersion,
+      zod: toolchain.zodVersion
+    }))
+      if (!current.dependencies?.[name] && !current.devDependencies?.[name])
+        additions[name] = version;
+    if (Object.keys(additions).length > 0)
+      writeFileSync3(file, JSON.stringify({ ...current, devDependencies: { ...current.devDependencies, ...additions } }, null, 2) + `
+`);
+  }
   success(`Created ${packagePath}.`);
 }
 function parseTemplate(value) {
@@ -209441,7 +209688,7 @@ function registerSourceInitCommand(agent) {
 }
 
 // src/commands/git/passthrough.ts
-import path3 from "node:path";
+import path4 from "node:path";
 function gitCommandCreatesObjects(args) {
   const objectCreatingCommands = new Set([
     "cherry-pick",
@@ -209462,7 +209709,7 @@ function gitCwdFromArgs(args) {
   let cwd = process.cwd();
   for (let i = 0;i < args.length; i += 1) {
     if (args[i] === "-C" && args[i + 1]) {
-      cwd = path3.resolve(cwd, args[i + 1]);
+      cwd = path4.resolve(cwd, args[i + 1]);
       i += 1;
     }
   }
@@ -209522,26 +209769,26 @@ async function runGitPassthrough(args, opts) {
 
 // src/commands/git/secrets.ts
 init_src();
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import path4 from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import path5 from "node:path";
 function readSecretsFile(packageRoot) {
-  const filePath = path4.join(packageRoot, SOURCE_SECRETS_FILENAME);
-  if (!existsSync4(filePath))
+  const filePath = path5.join(packageRoot, SOURCE_SECRETS_FILENAME);
+  if (!existsSync5(filePath))
     return { schemaVersion: 1, secrets: {} };
   return SourceSecretsFileSchema.parse(readYamlFile(filePath));
 }
 function writeSecretsFile(packageRoot, value) {
   const secretsFile = SourceSecretsFileSchema.parse(value);
-  writeYamlFile(path4.join(packageRoot, SOURCE_SECRETS_FILENAME), secretsFile);
+  writeYamlFile(path5.join(packageRoot, SOURCE_SECRETS_FILENAME), secretsFile);
 }
 async function readSecretInput(opts) {
   const selected = [opts.stdin, opts.valueFile].filter(Boolean).length;
   if (selected > 1)
     throw new Error("Pass only one of --stdin or --value-file.");
   if (opts.stdin)
-    return readFileSync5(0, "utf8").replace(/\n$/, "");
+    return readFileSync6(0, "utf8").replace(/\n$/, "");
   if (opts.valueFile)
-    return readFileSync5(opts.valueFile, "utf8").replace(/\n$/, "");
+    return readFileSync6(opts.valueFile, "utf8").replace(/\n$/, "");
   if (process.stdin.isTTY && process.stdout.isTTY) {
     await Promise.resolve().then(() => init_dist4());
     const answer = await Ce({ message: "Secret value" });
@@ -209597,7 +209844,7 @@ async function importSecrets(envFile, opts) {
   const client = new ApiClient(config);
   const sourcePath = `${context.packagePath}/${SOURCE_SECRETS_FILENAME}`;
   const entries = [];
-  const content = readFileSync5(envFile, "utf8");
+  const content = readFileSync6(envFile, "utf8");
   for (const line of content.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
@@ -209673,7 +209920,8 @@ var InstallLockPackageSchema = lazy(() => object({
   resolvedRef: string2().min(1),
   resolvedTag: string2().min(1).optional(),
   commit: CommitShaSchema,
-  dependencies: array(InstallLockPackageSchema)
+  dependencies: array(InstallLockPackageSchema),
+  compiledAgent: CompiledAgentSnapshotSchema.optional()
 }));
 var InstallLockfileSchema = object({
   lockfileVersion: literal(1),
@@ -209801,7 +210049,7 @@ async function resolveRemoteRefCommit(config, repository, ref) {
 function archivePackage(input) {
   rmSync(input.outDir, { recursive: true, force: true });
   mkdirSync3(input.outDir, { recursive: true });
-  const tarPath = path5.join(mkdtempSyncCompat("eigenpal-source-archive-"), "package.tar");
+  const tarPath = path6.join(mkdtempSyncCompat("eigenpal-source-archive-"), "package.tar");
   try {
     runGit(["archive", "--format=tar", `--output=${tarPath}`, input.ref, input.packagePath], {
       cwd: input.gitRoot
@@ -209813,7 +210061,7 @@ function archivePackage(input) {
     if (extract.status !== 0)
       throw new Error(extract.stderr.trim() || "tar extraction failed");
   } finally {
-    rmSync(path5.dirname(tarPath), { recursive: true, force: true });
+    rmSync(path6.dirname(tarPath), { recursive: true, force: true });
   }
 }
 async function tryHostedArchive(input) {
@@ -209840,7 +210088,7 @@ async function tryHostedArchive(input) {
     return false;
   rmSync(input.outDir, { recursive: true, force: true });
   mkdirSync3(input.outDir, { recursive: true });
-  const tarPath = path5.join(mkdtempSyncCompat("eigenpal-hosted-source-"), "package.tar");
+  const tarPath = path6.join(mkdtempSyncCompat("eigenpal-hosted-source-"), "package.tar");
   try {
     writeFileSync4(tarPath, Buffer.from(await response.arrayBuffer()));
     const extract = spawnSync3("tar", ["-xf", tarPath, "--strip-components", String(input.packagePath.split("/").length)], {
@@ -209851,30 +210099,33 @@ async function tryHostedArchive(input) {
       throw new Error(extract.stderr.trim() || "tar extraction failed");
     return true;
   } finally {
-    rmSync(path5.dirname(tarPath), { recursive: true, force: true });
+    rmSync(path6.dirname(tarPath), { recursive: true, force: true });
   }
 }
 function mkdtempSyncCompat(prefix) {
-  return mkdtempSync(path5.join(tmpdir(), prefix));
+  return mkdtempSync(path6.join(tmpdir(), prefix));
 }
 function dependencyInstallPath(parentRoot, packagePath) {
-  const modulesRoot = path5.resolve(parentRoot, "eigenpal_modules");
-  const destination = path5.resolve(modulesRoot, packagePath);
-  if (destination !== modulesRoot && !destination.startsWith(`${modulesRoot}${path5.sep}`)) {
+  const modulesRoot = path6.resolve(parentRoot, "eigenpal_modules");
+  const destination = path6.resolve(modulesRoot, packagePath);
+  if (destination !== modulesRoot && !destination.startsWith(`${modulesRoot}${path6.sep}`)) {
     throw new Error(`Dependency path escapes eigenpal_modules: ${packagePath}`);
   }
   return destination;
 }
 async function resolvePackageGraph(input) {
+  const budget = input.budget ?? { remaining: 32 };
+  if (--budget.remaining < 0)
+    throw new Error("Source dependencies exceed the 32-package resolution limit");
   const seen = input.seen ?? [];
   const key = `${input.packagePath}@${input.ref}`;
   if (seen.includes(key)) {
     throw new Error(`Dependency cycle detected: ${[...seen, key].join(" -> ")}`);
   }
   const resolved = await resolvePackageRef(input);
-  const tempDir = await mkdtemp(path5.join(tmpdir(), "eigenpal-install-resolve-"));
+  const tempDir = await mkdtemp(path6.join(tmpdir(), "eigenpal-install-resolve-"));
   try {
-    const packageRoot = path5.join(tempDir, "package");
+    const packageRoot = path6.join(tempDir, "package");
     const ref = resolved.commit;
     if (input.gitRoot) {
       archivePackage({
@@ -209892,22 +210143,28 @@ async function resolvePackageGraph(input) {
     })) {
       throw new Error(`Hosted source export unavailable for ${input.packagePath}@${ref}.`);
     }
-    const manifest = readPackageManifest(packageRoot);
+    const compiledAgent = input.packagePath.startsWith("agents/") && existsSync6(path6.join(packageRoot, "agent.ts")) ? await compileLocalAgent(packageRoot, input.config) : undefined;
+    const manifest = compiledAgent ? compiledAgent.definition.manifest : await readPackageManifest(packageRoot);
     const dependencies = "dependencies" in manifest ? Object.entries(manifest.dependencies ?? {}) : [];
+    const resolvedDependencies = [];
+    for (const [dependencyName, version] of dependencies)
+      resolvedDependencies.push(await resolvePackageGraph({
+        config: input.config,
+        gitRoot: input.gitRoot,
+        repository: input.repository,
+        packagePath: workspaceDependencyNameToPackagePath(dependencyName),
+        ref: SourceVersionRefSchema.parse(version),
+        seen: [...seen, key],
+        budget
+      }));
     return {
       packagePath: input.packagePath,
+      ...compiledAgent ? { compiledAgent } : {},
       requestedRef: input.ref,
       resolvedRef: resolved.resolvedRef,
       ...resolved.resolvedTag ? { resolvedTag: resolved.resolvedTag } : {},
       commit: resolved.commit,
-      dependencies: await Promise.all(dependencies.map(([dependencyName, version]) => resolvePackageGraph({
-        config: input.config,
-        gitRoot: input.gitRoot,
-        repository: input.repository,
-        packagePath: workspaceDependencyNameToPackagePath(dependencyName),
-        ref: SourceVersionRefSchema.parse(version),
-        seen: [...seen, key]
-      })))
+      dependencies: resolvedDependencies
     };
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
@@ -209935,6 +210192,20 @@ async function materializeLockPackage(input) {
       outDir: input.outDir
     });
   }
+  if (input.lockPackage.compiledAgent) {
+    if (!input.lockPackage.packagePath.startsWith("agents/") || !existsSync6(path6.join(input.outDir, "agent.ts")))
+      throw new Error("Compiled definition does not match installed agent package");
+    const { definition } = input.lockPackage.compiledAgent;
+    for (const key of ["inputSchema", "outputSchema"]) {
+      const filename = key === "inputSchema" ? "input-schema.json" : "output-schema.json";
+      if (existsSync6(path6.join(input.outDir, filename)) || existsSync6(path6.join(input.outDir, "eigenpal.yaml")))
+        throw new Error("Installed agent mixes TypeScript and legacy definitions");
+      if (definition[key] !== undefined)
+        writeFileSync4(path6.join(input.outDir, filename), JSON.stringify(definition[key], null, 2), {
+          flag: "wx"
+        });
+    }
+  }
   const occupied = new Set;
   for (const dependency of input.lockPackage.dependencies) {
     const dependencyPath = dependencyInstallPath(input.outDir, dependency.packagePath);
@@ -209952,12 +210223,12 @@ async function materializeLockPackage(input) {
   }
 }
 function writeLockfile(lockfilePath, lockfile) {
-  mkdirSync3(path5.dirname(lockfilePath), { recursive: true });
+  mkdirSync3(path6.dirname(lockfilePath), { recursive: true });
   writeFileSync4(lockfilePath, `${JSON.stringify(lockfile, null, 2)}
 `);
 }
 function readLockfile(lockfilePath) {
-  const parsed = InstallLockfileSchema.safeParse(JSON.parse(readFileSync6(lockfilePath, "utf8")));
+  const parsed = InstallLockfileSchema.safeParse(JSON.parse(readFileSync7(lockfilePath, "utf8")));
   if (!parsed.success) {
     throw new Error(`Invalid lockfile ${lockfilePath}: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
   }
@@ -210077,12 +210348,12 @@ async function syncLatestAutomation(client, packagePath) {
 async function cloneSource(opts) {
   const config = resolveConfig(opts);
   const repo = await getSourceRepository(config);
-  const outDir = opts.out ?? path5.basename(repo.gitRepositoryPath);
+  const outDir = opts.out ?? path6.basename(repo.gitRepositoryPath);
   runGit(["clone", repo.remoteUrl, outDir], {
     config,
     bootstrapRemoteUrl: repo.remoteUrl
   });
-  const clonedRoot = path5.resolve(process.cwd(), outDir);
+  const clonedRoot = path6.resolve(process.cwd(), outDir);
   await configureSourceGitRepo({
     gitRoot: clonedRoot,
     config,
@@ -210152,7 +210423,7 @@ async function release(versionOrBump, dir, opts) {
   };
   const config = resolveConfig(opts);
   checkRepoVersion(resolvedContext.gitRoot, true);
-  const validation = validatePackage(resolvedContext.packageRoot);
+  const validation = await validatePackage(resolvedContext.packageRoot, config);
   if (!validation.valid)
     throw new Error(`Package validation failed: ${validation.errors.join("; ")}`);
   const releaseMessage = opts.message?.trim() || `Release ${resolvedContext.packagePath}`;
@@ -210254,7 +210525,7 @@ async function install(packageRef, opts) {
     if (expectedPackagePath && lockfile.root.packagePath !== expectedPackagePath) {
       throw new Error(`Lockfile root package ${lockfile.root.packagePath} does not match requested package ${expectedPackagePath}.`);
     }
-    const destination = explicitRef ? path5.resolve(opts.out ?? path5.basename(lockfile.root.packagePath)) : packageDestination;
+    const destination = explicitRef ? path6.resolve(opts.out ?? path6.basename(lockfile.root.packagePath)) : packageDestination;
     if (!destination)
       throw new Error("No package context found for lockfile install.");
     const lockInstallGitRoot = explicitRef ? explicitGitRoot ?? sourceGitRoot : context.gitRoot;
@@ -210266,9 +210537,9 @@ async function install(packageRef, opts) {
         lockPackage: lockfile.root,
         outDir: destination
       });
-      writeLockfile(path5.join(destination, ".eigenpal", INSTALL_LOCKFILE_NAME), lockfile);
+      writeLockfile(path6.join(destination, ".eigenpal", INSTALL_LOCKFILE_NAME), lockfile);
     } else {
-      rmSync(path5.join(destination, "eigenpal_modules"), { recursive: true, force: true });
+      rmSync(path6.join(destination, "eigenpal_modules"), { recursive: true, force: true });
       for (const dependency of lockfile.root.dependencies) {
         await materializeLockPackage({
           config,
@@ -210286,12 +210557,12 @@ async function install(packageRef, opts) {
     const expectedPackagePath = packageRef ? parsePackageRef(packageRef).packagePath : null;
     const explicitGitRoot = explicitRef && expectedPackagePath && context.gitRoot ? packageManifestExists(context.gitRoot, expectedPackagePath) ? context.gitRoot : sourceGitRoot : sourceGitRoot;
     const repository = explicitRef && !explicitGitRoot ? await getSourceRepository(config, opts) : null;
-    const lockfilePath = opts.lockfile ?? path5.join(packageRef && opts.out ? path5.resolve(opts.out) : context.packageRoot ?? process.cwd(), ".eigenpal", INSTALL_LOCKFILE_NAME);
+    const lockfilePath = opts.lockfile ?? path6.join(packageRef && opts.out ? path6.resolve(opts.out) : context.packageRoot ?? process.cwd(), ".eigenpal", INSTALL_LOCKFILE_NAME);
     if (!explicitRef) {
       if (!context.packageRoot || !context.packagePath) {
         throw new Error("Run eigenpal agents install --frozen-lockfile inside a source package or pass a package ref.");
       }
-      const manifest = readPackageManifest(context.packageRoot);
+      const manifest = await readPackageManifest(context.packageRoot, config);
       const dependencies = "dependencies" in manifest ? Object.entries(manifest.dependencies ?? {}) : [];
       const inputHash = sourceLockfileInputHash({ packagePath: context.packagePath, dependencies });
       const existing = readLockfile(lockfilePath);
@@ -210314,9 +210585,9 @@ async function install(packageRef, opts) {
     const repository = explicitGitRoot ? null : await getSourceRepository(config, opts);
     if (parsed.ref === "main")
       warn("Installing @main uses draft source and is not reproducible.");
-    const intendedLockfile = opts.lockfile ?? path5.join(path5.resolve(opts.out ?? path5.basename(parsed.packagePath)), ".eigenpal", INSTALL_LOCKFILE_NAME);
+    const intendedLockfile = opts.lockfile ?? path6.join(path6.resolve(opts.out ?? path6.basename(parsed.packagePath)), ".eigenpal", INSTALL_LOCKFILE_NAME);
     const inputHash = sourceLockfileInputHash({ packageRef });
-    if (existsSync5(intendedLockfile)) {
+    if (existsSync6(intendedLockfile)) {
       const existing = readLockfile(intendedLockfile);
       if (existing.inputHash !== inputHash) {
         throw new Error(`Existing lockfile ${intendedLockfile} does not match requested package ref.`);
@@ -210331,7 +210602,7 @@ async function install(packageRef, opts) {
       packagePath: parsed.packagePath,
       ref: parsed.ref
     });
-    const outDir = path5.resolve(opts.out ?? path5.basename(parsed.packagePath));
+    const outDir = path6.resolve(opts.out ?? path6.basename(parsed.packagePath));
     await materializeLockPackage({
       config,
       gitRoot: explicitGitRoot,
@@ -210355,11 +210626,11 @@ async function install(packageRef, opts) {
   if (!context.gitRoot) {
     throw new Error("Run eigenpal agents install inside an organization source repository.");
   }
-  const manifest = readPackageManifest(context.packageRoot);
+  const manifest = await readPackageManifest(context.packageRoot, config);
   const dependencies = "dependencies" in manifest ? Object.entries(manifest.dependencies ?? {}) : [];
   const inputHash = sourceLockfileInputHash({ packagePath: context.packagePath, dependencies });
-  const intendedLockfile = opts.lockfile ?? path5.join(context.packageRoot, ".eigenpal", INSTALL_LOCKFILE_NAME);
-  if (existsSync5(intendedLockfile)) {
+  const intendedLockfile = opts.lockfile ?? path6.join(context.packageRoot, ".eigenpal", INSTALL_LOCKFILE_NAME);
+  if (existsSync6(intendedLockfile)) {
     const existing = readLockfile(intendedLockfile);
     if (existing.inputHash !== inputHash) {
       throw new Error(`Existing lockfile ${intendedLockfile} does not match current package inputs.`);
@@ -210379,7 +210650,7 @@ async function install(packageRef, opts) {
       ref: SourceVersionRefSchema.parse(version)
     })))
   };
-  rmSync(path5.join(context.packageRoot, "eigenpal_modules"), { recursive: true, force: true });
+  rmSync(path6.join(context.packageRoot, "eigenpal_modules"), { recursive: true, force: true });
   for (const dependency of root.dependencies) {
     await materializeLockPackage({
       config,
@@ -210437,7 +210708,7 @@ async function upgradeSource(opts) {
   const context = resolveGitSourceContext({ dir: opts.dir });
   if (!context.gitRoot)
     throw new Error("Not inside a Git repository.");
-  const manifestPath = path5.join(context.gitRoot, "eigenpal.yaml");
+  const manifestPath = path6.join(context.gitRoot, "eigenpal.yaml");
   const manifest = readRootManifest(context.gitRoot);
   if (!manifest.ok)
     throw new Error(manifest.error);
@@ -211155,8 +211426,8 @@ function zipSync(data, opts) {
 }
 
 // src/commands/agents/dataset.ts
-import { existsSync as existsSync8, promises as fs3 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync9, promises as fs3 } from "node:fs";
+import path9 from "node:path";
 
 // src/commands/dataset-review-request.ts
 import { mkdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
@@ -211164,8 +211435,8 @@ import { basename, dirname as dirname2, isAbsolute, join as join2, relative, res
 
 // src/commands/agents/shared.ts
 init_src();
-import { existsSync as existsSync6, promises as fs } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync7, promises as fs } from "node:fs";
+import path7 from "node:path";
 var PACKAGE_MANIFEST = "eigenpal.yaml";
 var DATASET_DIR = "dataset";
 var SCHEMA_FILENAMES = ["input-schema.json", "output-schema.json"];
@@ -211191,7 +211462,7 @@ function buildClient2(opts) {
   return new ApiClient(config);
 }
 async function writeBase64File(file, contentBase64) {
-  await fs.mkdir(path6.dirname(file), { recursive: true });
+  await fs.mkdir(path7.dirname(file), { recursive: true });
   await fs.writeFile(file, Buffer.from(contentBase64, "base64"));
 }
 async function pollRun(client, executionId, interval, maxWait, json = false) {
@@ -211901,24 +212172,24 @@ live dataset example-by-example by hand (reviewers can err), then
 
 // src/commands/agents/validation.ts
 init_src();
-import { existsSync as existsSync7, promises as fs2 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync8, promises as fs2 } from "node:fs";
+import path8 from "node:path";
 async function validateAgentProject(root) {
   const errors = [];
   const warnings = [];
   for (const [oldName] of LEGACY_LAYOUTS) {
-    if (existsSync7(path7.join(root, oldName))) {
+    if (existsSync8(path8.join(root, oldName))) {
       errors.push(`Legacy layout ${oldName}/ is removed; use Git source under agents/<slug>/`);
     }
   }
-  if (existsSync7(path7.join(root, "agent.yaml"))) {
+  if (existsSync8(path8.join(root, "agent.yaml"))) {
     errors.push("Legacy agent.yaml layout is removed; use eigenpal.yaml in a Git-backed package");
   }
-  if (existsSync7(path7.join(root, "agent"))) {
+  if (existsSync8(path8.join(root, "agent"))) {
     errors.push("Legacy agent/ directory is removed; use Git source (eigenpal agents clone)");
   }
-  const manifestPath = path7.join(root, PACKAGE_MANIFEST);
-  if (!existsSync7(manifestPath)) {
+  const manifestPath = path8.join(root, PACKAGE_MANIFEST);
+  if (existsSync8(path8.join(root, "agent.ts"))) {} else if (!existsSync8(manifestPath)) {
     errors.push(`Missing ${PACKAGE_MANIFEST}`);
   } else {
     try {
@@ -211927,15 +212198,15 @@ async function validateAgentProject(root) {
       errors.push(err instanceof Error ? err.message : String(err));
     }
   }
-  if (!existsSync7(path7.join(root, "AGENT.md")))
+  if (!existsSync8(path8.join(root, "AGENT.md")))
     warnings.push("Missing AGENT.md");
-  if (!existsSync7(path7.join(root, DATASET_DIR)))
+  if (!existsSync8(path8.join(root, DATASET_DIR)))
     warnings.push(`Missing ${DATASET_DIR}/`);
   for (const filename of SCHEMA_FILENAMES) {
-    const schemaPath = path7.join(root, filename);
-    if (!existsSync7(schemaPath))
+    const schemaPath = path8.join(root, filename);
+    if (!existsSync8(schemaPath))
       continue;
-    const validation = validateWorkspaceSchema(await fs2.readFile(schemaPath, "utf8"), filename);
+    const validation = validateAgentSchema(await fs2.readFile(schemaPath, "utf8"), filename);
     for (const issue of validation.errors) {
       errors.push(`${filename}: ${issue}`);
     }
@@ -211944,16 +212215,16 @@ async function validateAgentProject(root) {
 }
 async function validateDatasetDir(dir, opts = {}) {
   const errors = [];
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     errors.push(`Missing dataset directory: ${dir}`);
   for (const [oldName, newName] of LEGACY_LAYOUTS) {
-    if (path7.basename(dir) === oldName) {
+    if (path8.basename(dir) === oldName) {
       errors.push(`Use ${newName}/ instead of legacy ${oldName}/`);
     }
   }
   if (errors.length > 0)
     return { valid: false, errors };
-  if (existsSync7(path7.join(dir, "manifest.json"))) {
+  if (existsSync8(path8.join(dir, "manifest.json"))) {
     return {
       valid: false,
       errors: [
@@ -211961,8 +212232,8 @@ async function validateDatasetDir(dir, opts = {}) {
       ]
     };
   }
-  const examplesDir = path7.join(dir, "examples");
-  if (!existsSync7(examplesDir) || !(await fs2.stat(examplesDir)).isDirectory()) {
+  const examplesDir = path8.join(dir, "examples");
+  if (!existsSync8(examplesDir) || !(await fs2.stat(examplesDir)).isDirectory()) {
     errors.push("examples/: missing examples/ directory at dataset root");
     const flatFolders = await listImmediateDirs(dir);
     if (flatFolders.length > 0) {
@@ -211971,8 +212242,9 @@ async function validateDatasetDir(dir, opts = {}) {
     return { valid: false, errors };
   }
   const agentDir = opts.agentDir ?? process.cwd();
-  const inputSchema = await loadOptionalWorkspaceSchema(agentDir, "input-schema.json", errors);
-  const outputSchema = await loadOptionalWorkspaceSchema(agentDir, "output-schema.json", errors);
+  const compiled = existsSync8(path8.join(agentDir, "agent.ts")) ? await compileLocalAgent(agentDir, opts.config) : null;
+  const inputSchema = compiled ? compiled.definition.inputSchema ?? null : await loadOptionalWorkspaceSchema(agentDir, "input-schema.json", errors);
+  const outputSchema = compiled ? compiled.definition.outputSchema ?? null : await loadOptionalWorkspaceSchema(agentDir, "output-schema.json", errors);
   if (errors.length > 0)
     return { valid: false, errors };
   const examples = (await fs2.readdir(examplesDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
@@ -211980,7 +212252,7 @@ async function validateDatasetDir(dir, opts = {}) {
     return { valid: false, errors: ["examples/: dataset contains no examples"] };
   }
   for (const example of examples) {
-    errors.push(...await validateDatasetExample(path7.join(examplesDir, example), example, {
+    errors.push(...await validateDatasetExample(path8.join(examplesDir, example), example, {
       inputSchema,
       outputSchema
     }));
@@ -211995,8 +212267,8 @@ async function validateDatasetExample(exampleRoot, example, schemas) {
       `${label}: example folder name must be lowercase kebab/snake-case (matching ${DATASET_NAME_PATTERN})`
     ];
   }
-  const inputFiles = await listFilesUnder(path7.join(exampleRoot, "input"));
-  const expectedFiles = await listFilesUnder(path7.join(exampleRoot, "expected"));
+  const inputFiles = await listFilesUnder(path8.join(exampleRoot, "input"));
+  const expectedFiles = await listFilesUnder(path8.join(exampleRoot, "expected"));
   if (inputFiles.delete("arguments.json")) {
     errors.push(`${label}/input/arguments.json: legacy workflow archive path is no longer accepted; use input.json at the example root`);
   }
@@ -212005,8 +212277,8 @@ async function validateDatasetExample(exampleRoot, example, schemas) {
       errors.push(`${label}/expected/${legacy}: legacy workflow archive path is no longer accepted; use expected.json at the example root`);
     }
   }
-  const inputJsonPath = path7.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON);
-  if (!existsSync7(inputJsonPath)) {
+  const inputJsonPath = path8.join(exampleRoot, AGENT_EXAMPLE_INPUT_JSON);
+  if (!existsSync8(inputJsonPath)) {
     errors.push(`${label}/input.json: input.json is required`);
     return errors;
   }
@@ -212024,9 +212296,9 @@ async function validateDatasetExample(exampleRoot, example, schemas) {
     fieldPrefix: `${label}/input.json`,
     exampleLabel: label
   }));
-  const expectedJsonPath = path7.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON);
+  const expectedJsonPath = path8.join(exampleRoot, AGENT_EXAMPLE_EXPECTED_JSON);
   let expectedOutput = null;
-  if (existsSync7(expectedJsonPath)) {
+  if (existsSync8(expectedJsonPath)) {
     const expected = await readJson(expectedJsonPath, `${label}/expected.json`, errors);
     if (expected !== undefined) {
       if (isExpectedErrorRef(expected)) {
@@ -212049,8 +212321,8 @@ async function validateDatasetExample(exampleRoot, example, schemas) {
       errors.push(`${label}/expected/${file}: file is not referenced from expected.json (expected/ files require an expected.json with { "$file": "expected/${file}" })`);
     }
   }
-  const metaJsonPath = path7.join(exampleRoot, "meta.json");
-  if (existsSync7(metaJsonPath)) {
+  const metaJsonPath = path8.join(exampleRoot, "meta.json");
+  if (existsSync8(metaJsonPath)) {
     const meta = await readJson(metaJsonPath, `${label}/meta.json`, errors);
     if (meta !== undefined) {
       const parsed = DatasetMetaSchema.safeParse(meta);
@@ -212106,7 +212378,7 @@ function validateFileRefs(args) {
 }
 async function listFilesUnder(dir) {
   const out = new Set;
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return out;
   async function walk(current, relPrefix) {
     for (const entry of await fs2.readdir(current, { withFileTypes: true })) {
@@ -212114,7 +212386,7 @@ async function listFilesUnder(dir) {
         continue;
       const relative = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
       if (entry.isDirectory())
-        await walk(path7.join(current, entry.name), relative);
+        await walk(path8.join(current, entry.name), relative);
       else if (entry.isFile())
         out.add(relative);
     }
@@ -212140,11 +212412,11 @@ function isExpectedErrorRef(value) {
   return isJsonObject(value) && Object.keys(value).length === 1 && Object.prototype.hasOwnProperty.call(value, "$error");
 }
 async function loadOptionalWorkspaceSchema(agentDir, filename, errors) {
-  const schemaPath = path7.join(agentDir, filename);
-  if (!existsSync7(schemaPath))
+  const schemaPath = path8.join(agentDir, filename);
+  if (!existsSync8(schemaPath))
     return null;
   const raw = await fs2.readFile(schemaPath, "utf8");
-  const validation = validateWorkspaceSchema(raw, filename);
+  const validation = validateAgentSchema(raw, filename);
   for (const issue of validation.errors)
     errors.push(`${filename}: ${issue}`);
   if (!validation.valid)
@@ -212287,11 +212559,11 @@ async function pushDataset(agentId, opts) {
       cancelledMessage: "Dataset replace aborted"
     });
   }
-  const resolved = path8.resolve(opts.file);
+  const resolved = path9.resolve(opts.file);
   const stat = await fs3.stat(resolved);
   const archive = stat.isDirectory() ? await readDirAsZip(resolved) : new Uint8Array(await fs3.readFile(resolved));
   const form = new FormData;
-  form.set("file", new Blob([archive], { type: "application/zip" }), stat.isDirectory() ? "dataset.zip" : path8.basename(resolved));
+  form.set("file", new Blob([archive], { type: "application/zip" }), stat.isDirectory() ? "dataset.zip" : path9.basename(resolved));
   form.set("mode", opts.mode);
   const client = buildClient2(opts);
   const payload = await client.postFormData(`/v1/automations/${encodeURIComponent(agentAutomationId(agentId))}/dataset/import`, form);
@@ -212303,14 +212575,15 @@ async function pullDataset(agentId, opts) {
   const client = buildClient2(opts);
   const res = await client.getStream(`/v1/automations/${encodeURIComponent(agentAutomationId(agentId))}/dataset/export`);
   const archive = Buffer.from(await res.arrayBuffer());
-  const out = path8.resolve(opts.out ?? DATASET_DIR);
-  await fs3.mkdir(path8.dirname(out), { recursive: true });
+  const out = path9.resolve(opts.out ?? DATASET_DIR);
+  await fs3.mkdir(path9.dirname(out), { recursive: true });
   await fs3.writeFile(out.endsWith(".zip") ? out : `${out}.zip`, archive);
   success(`Pulled dataset to ${ui.bold(out.endsWith(".zip") ? out : `${out}.zip`)}`);
 }
 async function validateDatasetCommand(dir = DATASET_DIR, opts) {
-  const result = await validateDatasetDir(path8.resolve(dir), {
-    agentDir: path8.resolve(opts.agentDir ?? ".")
+  const result = await validateDatasetDir(path9.resolve(dir), {
+    agentDir: path9.resolve(opts.agentDir ?? "."),
+    config: resolveConfig(opts)
   });
   if (opts.json)
     return printJson2(result);
@@ -212321,14 +212594,14 @@ async function validateDatasetCommand(dir = DATASET_DIR, opts) {
   process.exit(1);
 }
 async function readDirAsZip(dir) {
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     throw new Error(`directory does not exist: ${dir}`);
   const files = {};
   async function walk(current, relPrefix) {
     for (const entry of await fs3.readdir(current, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
-      const absolute = path8.join(current, entry.name);
+      const absolute = path9.join(current, entry.name);
       const relative = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
       if (entry.isDirectory())
         await walk(absolute, relative);
@@ -212344,8 +212617,8 @@ async function readDirAsZip(dir) {
 
 // src/commands/agents/env.ts
 init_src();
-import { existsSync as existsSync9, promises as fs4, readFileSync as readFileSync7 } from "node:fs";
-import path9 from "node:path";
+import { existsSync as existsSync10, promises as fs4, readFileSync as readFileSync8 } from "node:fs";
+import path10 from "node:path";
 
 // src/commands/agents/target.ts
 init_src();
@@ -212386,7 +212659,7 @@ async function pullAgentEnv(target, opts) {
     throw new Error("--format must be shell or dotenv");
   }
   const client = buildClient2(opts);
-  const requests = target ? await collectEncryptedSecretsForTarget(client, target) : await collectEncryptedSecrets(path9.resolve(opts.dir ?? "."));
+  const requests = target ? await collectEncryptedSecretsForTarget(client, target) : await collectEncryptedSecrets(path10.resolve(opts.dir ?? "."));
   if (requests.length === 0)
     return;
   const payload = await client.post("/v1/source/secrets/decrypt", {
@@ -212449,12 +212722,12 @@ async function readOptionalSourceFile(client, query) {
   }
 }
 async function collectEncryptedSecrets(root) {
-  const roots = [root, ...await listModulePackageRoots(path9.join(root, "eigenpal_modules"))];
+  const roots = [root, ...await listModulePackageRoots(path10.join(root, "eigenpal_modules"))];
   const seen = new Set;
   const requests = [];
   for (const packageRoot of roots) {
-    const secretsPath = path9.join(packageRoot, SOURCE_SECRETS_FILENAME);
-    if (!existsSync9(secretsPath))
+    const secretsPath = path10.join(packageRoot, SOURCE_SECRETS_FILENAME);
+    if (!existsSync10(secretsPath))
       continue;
     const parsed = SourceSecretsFileSchema.parse(exports_dist.parse(await fs4.readFile(secretsPath, "utf8")));
     const sourcePath = sourcePathForInstalledPackage(root, packageRoot);
@@ -212476,16 +212749,16 @@ async function collectEncryptedSecrets(root) {
   return requests;
 }
 async function listModulePackageRoots(modulesRoot) {
-  if (!existsSync9(modulesRoot))
+  if (!existsSync10(modulesRoot))
     return [];
   const result = [];
   for (const type of await fs4.readdir(modulesRoot)) {
-    const typeRoot = path9.join(modulesRoot, type);
+    const typeRoot = path10.join(modulesRoot, type);
     const typeStat = await fs4.stat(typeRoot).catch(() => null);
     if (!typeStat?.isDirectory())
       continue;
     for (const slug of await fs4.readdir(typeRoot)) {
-      const packageRoot = path9.join(typeRoot, slug);
+      const packageRoot = path10.join(typeRoot, slug);
       const packageStat = await fs4.stat(packageRoot).catch(() => null);
       if (packageStat?.isDirectory())
         result.push(packageRoot);
@@ -212494,16 +212767,16 @@ async function listModulePackageRoots(modulesRoot) {
   return result;
 }
 function sourcePathForInstalledPackage(root, packageRoot) {
-  const sourceRelative = path9.relative(root, packageRoot).replace(/\\/g, "/");
+  const sourceRelative = path10.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 = path10.relative(path10.join(root, "eigenpal_modules"), packageRoot).replace(/\\/g, "/");
   if (!relative.startsWith(".."))
     return relative;
-  const lockfilePath = path9.join(root, ".eigenpal", "eigenpal.lock");
-  if (packageRoot === root && existsSync9(lockfilePath)) {
-    const lockfile = JSON.parse(readFileSync7(lockfilePath, "utf8"));
+  const lockfilePath = path10.join(root, ".eigenpal", "eigenpal.lock");
+  if (packageRoot === root && existsSync10(lockfilePath)) {
+    const lockfile = JSON.parse(readFileSync8(lockfilePath, "utf8"));
     if (typeof lockfile.root?.packagePath === "string")
       return lockfile.root.packagePath;
   }
@@ -213360,7 +213633,7 @@ async function cancelExperiment(agentId, batchId, opts) {
 // src/commands/agents/files.ts
 import { createHash as createHash2 } from "node:crypto";
 import { promises as fs6 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function registerAgentFileCommands(agent) {
   const file = 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");
@@ -213389,12 +213662,12 @@ async function getAgentFile(agentId, remotePath, opts) {
   const payload = await readAgentFile(client, agentId, remotePath);
   if (opts.json)
     return printJson2(payload);
-  const out = path10.resolve(opts.out ?? payload.path);
+  const out = path11.resolve(opts.out ?? payload.path);
   await writeBase64File(out, payload.contentBase64);
   success(`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, path11.resolve(localPath), opts);
   if (opts.json)
     return printJson2(report);
   renderAgentFileDiff(report);
@@ -213544,7 +213817,7 @@ async function stopSession(sessionId, opts) {
 init_src();
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { promises as fs15, readFileSync as readFileSync12 } from "node:fs";
+import { promises as fs15, readFileSync as readFileSync13 } from "node:fs";
 import path15 from "node:path";
 
 // src/lib/resolve-workflow.ts
@@ -214523,7 +214796,7 @@ function assertXlsxTemplateWorkload(buffer, data, limits = xlsxTemplateRenderLim
 }
 
 // ../common/src/xlsx-template.js
-var path11 = __require("path");
+var path12 = __require("path");
 var imageSize2 = (init_dist5(), __toCommonJS(exports_dist2)).imageSize;
 var fs7 = __require("fs");
 var etree = require_elementtree();
@@ -214665,17 +214938,17 @@ class Workbook {
         "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing"
       ];
       if (needsFileCopy.indexOf(relType) !== -1) {
-        var sheetDirectory = path11.dirname(sheet.filename);
-        var sourceFilePath = path11.join(sheetDirectory, target).replace(/\\/g, "/");
+        var sheetDirectory = path12.dirname(sheet.filename);
+        var sourceFilePath = path12.join(sheetDirectory, target).replace(/\\/g, "/");
         var sourceFile = self2.archive.file(sourceFilePath);
         if (sourceFile) {
-          var fileExtension = path11.extname(target);
-          var fileBaseName = path11.basename(target, fileExtension);
-          var fileDir = path11.dirname(target);
+          var fileExtension = path12.extname(target);
+          var fileBaseName = path12.basename(target, fileExtension);
+          var fileDir = path12.dirname(target);
           var baseNameWithoutNumber = fileBaseName.replace(/\d+$/, "");
           var newFileName = baseNameWithoutNumber + newSheetIndex + fileExtension;
-          var newTarget = path11.join(fileDir, newFileName).replace(/\\/g, "/");
-          var newFilePath = path11.join(sheetDirectory, newTarget).replace(/\\/g, "/");
+          var newTarget = path12.join(fileDir, newFileName).replace(/\\/g, "/");
+          var newFilePath = path12.join(sheetDirectory, newTarget).replace(/\\/g, "/");
           var binaryContent = sourceFile.asBinary();
           if (relType === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing") {
             binaryContent = binaryContent.replace(/data="\d+"/, 'data="' + newSheetIndex + '"');
@@ -214712,8 +214985,8 @@ class Workbook {
     var self2 = this;
     var order = ["worksheet", "theme", "styles", "sharedStrings"];
     self2.workbookRels.findall("*").sort(function(rel1, rel2) {
-      var index1 = order.indexOf(path11.basename(rel1.attrib.Type));
-      var index2 = order.indexOf(path11.basename(rel2.attrib.Type));
+      var index1 = order.indexOf(path12.basename(rel1.attrib.Type));
+      var index2 = order.indexOf(path12.basename(rel2.attrib.Type));
       if (index1 < 0 && index2 >= 0)
         return 1;
       if (index1 >= 0 && index2 < 0)
@@ -214733,7 +215006,7 @@ class Workbook {
       item.attrib["r:id"] = "rId" + (index + 1);
       item.attrib.sheetId = (index + 1).toString();
     });
-    self2.archive.file(self2.prefix + "/" + "_rels" + "/" + path11.basename(self2.workbookPath) + ".rels", etree.tostring(self2.workbookRels));
+    self2.archive.file(self2.prefix + "/" + "_rels" + "/" + path12.basename(self2.workbookPath) + ".rels", etree.tostring(self2.workbookRels));
     self2.archive.file(self2.workbookPath, etree.tostring(self2.workbook));
     self2.sheets = self2.loadSheets(self2.prefix, self2.workbook, self2.workbookRels);
   }
@@ -214745,9 +215018,9 @@ class Workbook {
     self2.archive = new zip(data, { base64: false, checkCRC32: true });
     var rels = etree.parse(self2.archive.file("_rels/.rels").asText()).getroot(), workbookPath = rels.find("Relationship[@Type='" + DOCUMENT_RELATIONSHIP + "']").attrib.Target;
     self2.workbookPath = workbookPath;
-    self2.prefix = path11.dirname(workbookPath);
+    self2.prefix = path12.dirname(workbookPath);
     self2.workbook = etree.parse(self2.archive.file(workbookPath).asText()).getroot();
-    self2.workbookRels = etree.parse(self2.archive.file(self2.prefix + "/" + "_rels" + "/" + path11.basename(workbookPath) + ".rels").asText()).getroot();
+    self2.workbookRels = etree.parse(self2.archive.file(self2.prefix + "/" + "_rels" + "/" + path12.basename(workbookPath) + ".rels").asText()).getroot();
     self2.sheets = self2.loadSheets(self2.prefix, self2.workbook, self2.workbookRels);
     self2.calChainRel = self2.workbookRels.find("Relationship[@Type='" + CALC_CHAIN_RELATIONSHIP + "']");
     if (self2.calChainRel) {
@@ -215027,7 +215300,7 @@ class Workbook {
   }
   loadSheetRels(sheetFilename) {
     var self2 = this;
-    var sheetDirectory = path11.dirname(sheetFilename), sheetName = path11.basename(sheetFilename), relsFilename = path11.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/"), relsFile = self2.archive.file(relsFilename);
+    var sheetDirectory = path12.dirname(sheetFilename), sheetName = path12.basename(sheetFilename), relsFilename = path12.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/"), relsFile = self2.archive.file(relsFilename);
     if (relsFile === null) {
       return self2.initSheetRels(sheetFilename);
     }
@@ -215035,7 +215308,7 @@ class Workbook {
     return rels;
   }
   initSheetRels(sheetFilename) {
-    var sheetDirectory = path11.dirname(sheetFilename), sheetName = path11.basename(sheetFilename), relsFilename = path11.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/");
+    var sheetDirectory = path12.dirname(sheetFilename), sheetName = path12.basename(sheetFilename), relsFilename = path12.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/");
     var element = etree.Element;
     var ElementTree = etree.ElementTree;
     var root = element("Relationships");
@@ -215046,16 +215319,16 @@ class Workbook {
   }
   loadDrawing(sheet, sheetFilename, rels) {
     var self2 = this;
-    var sheetDirectory = path11.dirname(sheetFilename), sheetName = path11.basename(sheetFilename), drawing = { filename: "", root: null };
+    var sheetDirectory = path12.dirname(sheetFilename), sheetName = path12.basename(sheetFilename), drawing = { filename: "", root: null };
     var drawingPart = sheet.find("drawing");
     if (drawingPart === null) {
       drawing = self2.initDrawing(sheet, rels);
       return drawing;
     }
-    var relationshipId = drawingPart.attrib["r:id"], target = rels.find("Relationship[@Id='" + relationshipId + "']").attrib.Target, drawingFilename = path11.join(sheetDirectory, target).replace(/\\/g, "/"), drawingTree = etree.parse(self2.archive.file(drawingFilename).asText());
+    var relationshipId = drawingPart.attrib["r:id"], target = rels.find("Relationship[@Id='" + relationshipId + "']").attrib.Target, drawingFilename = path12.join(sheetDirectory, target).replace(/\\/g, "/"), drawingTree = etree.parse(self2.archive.file(drawingFilename).asText());
     drawing.filename = drawingFilename;
     drawing.root = drawingTree.getroot();
-    drawing.relFilename = path11.dirname(drawingFilename) + "/_rels/" + path11.basename(drawingFilename) + ".rels";
+    drawing.relFilename = path12.dirname(drawingFilename) + "/_rels/" + path12.basename(drawingFilename) + ".rels";
     var relFile = self2.archive.file(drawing.relFilename);
     if (relFile === null) {
       drawing.relRoot = etree.Element("Relationships");
@@ -215127,7 +215400,7 @@ class Workbook {
   }
   loadTables(sheet, sheetFilename) {
     var self2 = this;
-    var sheetDirectory = path11.dirname(sheetFilename), sheetName = path11.basename(sheetFilename), relsFilename = sheetDirectory + "/" + "_rels" + "/" + sheetName + ".rels", relsFile = self2.archive.file(relsFilename), tables = [];
+    var sheetDirectory = path12.dirname(sheetFilename), sheetName = path12.basename(sheetFilename), relsFilename = sheetDirectory + "/" + "_rels" + "/" + sheetName + ".rels", relsFile = self2.archive.file(relsFilename), tables = [];
     if (relsFile === null) {
       return tables;
     }
@@ -216431,7 +216704,7 @@ function extractErrorMessage(error) {
 }
 // src/lib/xlsx-workbook.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 
 // ../../node_modules/xlsx/xlsx.mjs
 /*! xlsx.js (C) 2013-present SheetJS -- http://sheetjs.com */
@@ -241279,7 +241552,7 @@ function parseSheetSelectionList(raw) {
 }
 function extractXlsxComparableText(filePath) {
   try {
-    const buffer = readFileSync8(filePath);
+    const buffer = readFileSync9(filePath);
     const result = computeXlsxWorkbookComparisonDigest(buffer);
     if (result.status === "ok") {
       return { text: result.digest };
@@ -241298,18 +241571,18 @@ function extractXlsxComparableText(filePath) {
 }
 
 // src/lib/execution-artifacts.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
 import { join as join5 } from "path";
 
 // src/lib/format.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 import { extname as extname2, resolve as resolve3 } from "path";
 var PRETTIER_EXTENSIONS = new Set([".json", ".yaml", ".yml"]);
 async function formatFileIfAvailable(filepath) {
   if (!PRETTIER_EXTENSIONS.has(extname2(filepath)))
     return;
   try {
-    const content = readFileSync9(filepath, "utf-8");
+    const content = readFileSync10(filepath, "utf-8");
     const prettier = await Promise.resolve().then(() => (init_prettier(), {}));
     const formatted = await format2(content, {
       filepath: resolve3(filepath)
@@ -241482,7 +241755,7 @@ function gradeAgainstExpected(expected, actual) {
 }
 
 // src/lib/payload.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
 import { join as join7 } from "path";
 
 // src/lib/fs-helpers.ts
@@ -241497,7 +241770,7 @@ var DATASET_EXAMPLES_DIR = ["dataset", "examples"];
 function resolveEvalBaseDir(dir) {
   const candidates = [join7(dir, ...DATASET_EXAMPLES_DIR), join7(...DATASET_EXAMPLES_DIR)];
   for (const candidate of candidates) {
-    if (existsSync11(candidate))
+    if (existsSync12(candidate))
       return candidate;
   }
   return null;
@@ -243057,7 +243330,7 @@ async function downloadStreamToFile(client, url, target) {
 function extractComparableText(file) {
   const ext = path15.extname(file).toLowerCase();
   if ([".txt", ".md", ".json", ".csv", ".xml"].includes(ext)) {
-    return { text: readFileSync12(file, "utf8") };
+    return { text: readFileSync13(file, "utf8") };
   }
   if (ext === ".xlsx" || ext === ".xls") {
     return extractXlsxComparableText(file);
@@ -243183,8 +243456,8 @@ async function validateAgentCommand(dir = ".", opts) {
   const root = path16.resolve(dir);
   const legacy = await validateAgentProject(root);
   const result = { ...legacy };
-  if (existsSync12(path16.join(root, PACKAGE_MANIFEST))) {
-    const source = validateSourcePackage(root);
+  if (existsSync13(path16.join(root, "agent.ts")) || existsSync13(path16.join(root, PACKAGE_MANIFEST))) {
+    const source = await validateSourcePackage(root, resolveConfig(opts));
     result.valid = legacy.valid && source.valid;
     result.packagePath = source.packagePath;
     for (const issue of source.errors) {
@@ -243722,7 +243995,7 @@ async function completion(shell, program) {
 }
 
 // src/commands/docs.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "node:fs";
 var docsCache = null;
 function bundledDocs() {
   if (docsCache)
@@ -243731,11 +244004,11 @@ function bundledDocs() {
     new URL("./docs-bundle.json", import.meta.url),
     new URL("../docs-bundle.json", import.meta.url)
   ];
-  const bundleUrl = candidates.find((candidate) => existsSync13(candidate));
+  const bundleUrl = candidates.find((candidate) => existsSync14(candidate));
   if (!bundleUrl) {
     throw new Error("Bundled documentation asset is missing. Reinstall the Eigenpal CLI.");
   }
-  const parsed = JSON.parse(readFileSync13(bundleUrl, "utf8"));
+  const parsed = JSON.parse(readFileSync14(bundleUrl, "utf8"));
   if (!Array.isArray(parsed.entries)) {
     throw new Error("Bundled documentation asset is invalid. Reinstall the Eigenpal CLI.");
   }
@@ -243856,7 +244129,7 @@ function matchingSnippet(content, terms) {
 
 // src/lib/email-servers-cli.ts
 init_src();
-import { existsSync as existsSync14, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync15 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 var SECRET_KEYS = new Set(["apiKey", "password", "caPem", "ciphertext"]);
 var SMTP_UPDATE_TARGET_FIELDS = ["host", "port", "security", "fromEmail", "fromName"];
@@ -243908,7 +244181,7 @@ function readConfigObject(opts) {
     const filePath = opts.configFile === "-" ? undefined : resolve4(opts.configFile);
     let raw;
     try {
-      raw = opts.configFile === "-" ? readFileSync14(0, "utf8") : readFileSync14(filePath, "utf8");
+      raw = opts.configFile === "-" ? readFileSync15(0, "utf8") : readFileSync15(filePath, "utf8");
     } catch (err) {
       const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
       if (code === "ENOENT") {
@@ -243942,12 +244215,12 @@ async function readSecretInput2(label, opts, required) {
     throw new Error(`Pass only one of --${label}-stdin or --${label}-file.`);
   }
   if (opts.stdin) {
-    return readFileSync14(0, "utf8").replace(/\n$/, "");
+    return readFileSync15(0, "utf8").replace(/\n$/, "");
   }
   if (opts.file) {
     const filePath = opts.file === "-" ? undefined : resolve4(opts.file);
     try {
-      return (opts.file === "-" ? readFileSync14(0, "utf8") : readFileSync14(filePath, "utf8")).replace(/\n$/, "");
+      return (opts.file === "-" ? readFileSync15(0, "utf8") : readFileSync15(filePath, "utf8")).replace(/\n$/, "");
     } catch (err) {
       const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
       if (code === "ENOENT") {
@@ -244299,10 +244572,10 @@ function registerEmailServersCommands(program) {
 init_dist4();
 import {
   copyFileSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync5,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync15,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync16,
   statSync as statSync4,
   writeFileSync as writeFileSync7
 } from "node:fs";
@@ -244328,10 +244601,10 @@ function isValidProjectName(name) {
 function resolveTemplatesRoot() {
   const here = dirname5(fileURLToPath6(import.meta.url));
   const srcCandidate = resolve5(here, "..", "..", "templates");
-  if (existsSync15(srcCandidate))
+  if (existsSync16(srcCandidate))
     return srcCandidate;
   const distCandidate = resolve5(here, "templates");
-  if (existsSync15(distCandidate))
+  if (existsSync16(distCandidate))
     return distCandidate;
   throw new Error(`Cannot locate bundled templates. Looked in:
   ${srcCandidate}
@@ -244343,7 +244616,7 @@ async function init(name, opts) {
   }
   const target = resolve5(process.cwd(), opts.dir ?? name);
   assertSafeTargetDir(target, opts.dir);
-  if (existsSync15(target) && readdirSync4(target).length > 0) {
+  if (existsSync16(target) && readdirSync5(target).length > 0) {
     throw new Error(`Target directory ${relative3(process.cwd(), target)} exists and is not empty.`);
   }
   let template;
@@ -244358,7 +244631,7 @@ async function init(name, opts) {
     template = await promptForTemplate();
   }
   const sourceRoot = join8(resolveTemplatesRoot(), template);
-  if (!existsSync15(sourceRoot)) {
+  if (!existsSync16(sourceRoot)) {
     throw new Error(`Template directory missing on disk: ${sourceRoot}`);
   }
   const written = copyTemplate(sourceRoot, target, name);
@@ -244400,7 +244673,7 @@ function copyTemplate(src, dst, projectName) {
   const stack = [src];
   while (stack.length > 0) {
     const dir = stack.pop();
-    for (const entry of readdirSync4(dir)) {
+    for (const entry of readdirSync5(dir)) {
       const sourcePath = join8(dir, entry);
       const relativePath = relative3(src, sourcePath);
       const targetPath = join8(dst, relativePath);
@@ -244411,7 +244684,7 @@ function copyTemplate(src, dst, projectName) {
       }
       mkdirSync5(dirname5(targetPath), { recursive: true });
       if (isTextFile(sourcePath)) {
-        const text = readFileSync15(sourcePath, "utf-8").replaceAll(PLACEHOLDER, projectName);
+        const text = readFileSync16(sourcePath, "utf-8").replaceAll(PLACEHOLDER, projectName);
         writeFileSync7(targetPath, text);
       } else {
         copyFileSync(sourcePath, targetPath);
@@ -245401,7 +245674,7 @@ function parseInputFileSpecs(inputFile) {
 
 // src/lib/format-eigenpal.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
 import { join as join9, resolve as resolve6 } from "path";
 var PRETTRC_NAMES = [
   ".prettierrc",
@@ -245415,14 +245688,14 @@ var PRETTRC_NAMES = [
 ];
 function hasPrettierConfig(cwd) {
   for (const name of PRETTRC_NAMES) {
-    if (existsSync16(join9(cwd, name)))
+    if (existsSync17(join9(cwd, name)))
       return true;
   }
   try {
     const pkgPath = join9(cwd, "package.json");
-    if (!existsSync16(pkgPath))
+    if (!existsSync17(pkgPath))
       return false;
-    const raw = readFileSync16(pkgPath, "utf-8");
+    const raw = readFileSync17(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     return pkg != null && typeof pkg === "object" && "prettier" in pkg;
   } catch {
@@ -245432,7 +245705,7 @@ function hasPrettierConfig(cwd) {
 function formatEigenpalDirIfAvailable(dir) {
   const cwd = process.cwd();
   const absDir = resolve6(cwd, dir);
-  if (!existsSync16(absDir))
+  if (!existsSync17(absDir))
     return;
   if (!hasPrettierConfig(cwd))
     return;
@@ -245566,11 +245839,11 @@ async function rerunTarget(runId, opts) {
 init_dist4();
 import { createHash as createHash5 } from "node:crypto";
 import {
-  existsSync as existsSync17,
-  lstatSync,
+  existsSync as existsSync18,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync17,
-  readdirSync as readdirSync5,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync6,
   rmSync as rmSync2,
   rmdirSync,
   unlinkSync as unlinkSync2,
@@ -245652,10 +245925,10 @@ var MANIFEST_NAME = ".eigenpal-manifest.json";
 function resolveSkillSource() {
   const here = dirname6(fileURLToPath7(import.meta.url));
   const srcCandidate = resolve7(here, "..", "..", "skill");
-  if (existsSync17(srcCandidate))
+  if (existsSync18(srcCandidate))
     return srcCandidate;
   const distCandidate = resolve7(here, "skill");
-  if (existsSync17(distCandidate))
+  if (existsSync18(distCandidate))
     return distCandidate;
   throw new Error(`Cannot locate bundled skill content. Looked in:
   ${srcCandidate}
@@ -245692,15 +245965,15 @@ async function installSkill(opts) {
   for (const relativePath of sourceFiles) {
     const sourcePath = join11(source, relativePath);
     const targetPath = join11(target, relativePath);
-    const sourceBytes = templateSourceFile(relativePath, readFileSync17(sourcePath), cliVersion);
+    const sourceBytes = templateSourceFile(relativePath, readFileSync18(sourcePath), cliVersion);
     const sourceHash = sha256(sourceBytes);
-    if (!existsSync17(targetPath)) {
+    if (!existsSync18(targetPath)) {
       mkdirSync6(dirname6(targetPath), { recursive: true });
       writeFileSync8(targetPath, sourceBytes);
       written += 1;
       continue;
     }
-    const targetBytes = readFileSync17(targetPath);
+    const targetBytes = readFileSync18(targetPath);
     const targetHash = sha256(targetBytes);
     if (targetHash === sourceHash) {
       skipped += 1;
@@ -245732,9 +246005,9 @@ async function installSkill(opts) {
   const manifestEntries = [];
   for (const relativePath of sourceFiles) {
     const targetPath = join11(target, relativePath);
-    if (!existsSync17(targetPath))
+    if (!existsSync18(targetPath))
       continue;
-    manifestEntries.push({ path: relativePath, sha256: sha256(readFileSync17(targetPath)) });
+    manifestEntries.push({ path: relativePath, sha256: sha256(readFileSync18(targetPath)) });
   }
   const manifest = {
     cliVersion,
@@ -245775,9 +246048,9 @@ async function uninstallSkill(opts) {
       console.error(`Refusing to touch ${path}: manifest path escapes ${targetReal}`);
       continue;
     }
-    if (!existsSync17(path))
+    if (!existsSync18(path))
       continue;
-    const currentHash = sha256(readFileSync17(path));
+    const currentHash = sha256(readFileSync18(path));
     if (currentHash !== entry.sha256 && !opts.yes) {
       kept += 1;
       continue;
@@ -245978,20 +246251,20 @@ function hintFor(tool, installed, detected) {
   return tool.relativePath;
 }
 function isInstalled(cwd, tool) {
-  return existsSync17(join11(cwd, tool.relativePath, MANIFEST_NAME));
+  return existsSync18(join11(cwd, tool.relativePath, MANIFEST_NAME));
 }
 function isProjectUsing(cwd, tool) {
-  return tool.detectPaths.some((p) => existsSync17(join11(cwd, p)));
+  return tool.detectPaths.some((p) => existsSync18(join11(cwd, p)));
 }
 function listFiles(root) {
   const out = [];
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    for (const entry of readdirSync5(dir)) {
+    for (const entry of readdirSync6(dir)) {
       const full = join11(dir, entry);
       const rel = relative4(root, full);
-      const stats = lstatSync(full);
+      const stats = lstatSync2(full);
       if (stats.isDirectory()) {
         stack.push(full);
         continue;
@@ -246005,10 +246278,10 @@ function listFiles(root) {
 }
 function readManifest(target) {
   const path = join11(target, MANIFEST_NAME);
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     return null;
   try {
-    return JSON.parse(readFileSync17(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
@@ -246022,8 +246295,8 @@ function readCliVersion() {
       resolve7(here, "..", "package.json")
     ];
     for (const candidate of candidates) {
-      if (existsSync17(candidate)) {
-        const pkg = JSON.parse(readFileSync17(candidate, "utf-8"));
+      if (existsSync18(candidate)) {
+        const pkg = JSON.parse(readFileSync18(candidate, "utf-8"));
         if (pkg.name && pkg.name !== "@eigenpal/cli")
           continue;
         if (pkg.version)
@@ -246034,13 +246307,13 @@ function readCliVersion() {
   return "unknown";
 }
 function pruneEmptyDirs(root) {
-  if (!existsSync17(root))
+  if (!existsSync18(root))
     return;
   const stack = [];
   const collect = (dir) => {
-    for (const entry of readdirSync5(dir)) {
+    for (const entry of readdirSync6(dir)) {
       const full = join11(dir, entry);
-      if (lstatSync(full).isDirectory())
+      if (lstatSync2(full).isDirectory())
         collect(full);
     }
     stack.push(dir);
@@ -246048,7 +246321,7 @@ function pruneEmptyDirs(root) {
   collect(root);
   for (const dir of stack) {
     try {
-      if (readdirSync5(dir).length === 0)
+      if (readdirSync6(dir).length === 0)
         rmdirSync(dir);
     } catch {}
   }
@@ -246933,12 +247206,12 @@ function looksLikeFreeform(prop) {
   return prop.pattern !== undefined || prop.format !== undefined;
 }
 // src/commands/workflow/index.ts
-import { existsSync as existsSync23, promises as fs21 } from "node:fs";
+import { existsSync as existsSync24, promises as fs21 } from "node:fs";
 import path19 from "node:path";
 
 // src/lib/local-templates.ts
 init_src();
-import { existsSync as existsSync18, promises as fs18, realpathSync as realpathSync4, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync19, promises as fs18, realpathSync as realpathSync4, statSync as statSync5 } from "node:fs";
 import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute2, relative as relative5, resolve as resolve8, sep } from "node:path";
 
 // src/lib/office-template.ts
@@ -247181,7 +247454,7 @@ function walkTemplateSteps(steps, visit) {
 }
 function resolveWorkflowProjectRoot(workflowFile) {
   const abs = resolve8(workflowFile);
-  if (!existsSync18(abs)) {
+  if (!existsSync19(abs)) {
     throw new Error(`Workflow file not found: ${abs}`);
   }
   return dirname7(realpathSync4(abs));
@@ -247204,7 +247477,7 @@ function resolveWorkflowTemplatePath(workflowFile, templatePath, opts = {}) {
   if (!opts.allowExternal) {
     assertInsideProject(projectRoot, templatePath, candidate);
   }
-  if (!existsSync18(candidate)) {
+  if (!existsSync19(candidate)) {
     throw new Error(`Local template not found: ${candidate}`);
   }
   const real = realpathSync4(candidate);
@@ -247386,13 +247659,13 @@ function rewriteLocalTemplateYaml(yamlText, resolved) {
 }
 
 // src/commands/workflow/clear.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync6 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync7, rmSync as rmSync3, statSync as statSync6 } from "fs";
 import { basename as basename3, join as join12 } from "path";
 var EMPTY_REPORT = { removed: 0, kept: 0, touched: 0 };
 function getDirectoryEntries(path) {
-  if (!existsSync19(path))
+  if (!existsSync20(path))
     return [];
-  return readdirSync6(path).filter((entry) => statSync6(join12(path, entry)).isDirectory()).sort();
+  return readdirSync7(path).filter((entry) => statSync6(join12(path, entry)).isDirectory()).sort();
 }
 function removeDirEntriesWithRetention(path, removeAll) {
   const entries = getDirectoryEntries(path);
@@ -247411,10 +247684,10 @@ function removeDirEntriesWithRetention(path, removeAll) {
   return { removed, kept: keepSet.size, touched: entries.length };
 }
 function removeJudgeSummaryFilesWithRetention(exampleDir, removeAll) {
-  if (!existsSync19(exampleDir))
+  if (!existsSync20(exampleDir))
     return EMPTY_REPORT;
   const stampByFile = new Map;
-  for (const fileName of readdirSync6(exampleDir).sort()) {
+  for (const fileName of readdirSync7(exampleDir).sort()) {
     const match = /^llm-judge-summary-(.+)\.(json|md)$/.exec(fileName);
     if (match)
       stampByFile.set(fileName, match[1]);
@@ -247443,7 +247716,7 @@ function getTargetExampleDirs(dir, exampleNames) {
     error2(`No dataset/examples directory at ${join12(dir, "dataset", "examples")}`);
     process.exit(1);
   }
-  const all = readdirSync6(baseDir).filter((entry) => statSync6(join12(baseDir, entry)).isDirectory());
+  const all = readdirSync7(baseDir).filter((entry) => statSync6(join12(baseDir, entry)).isDirectory());
   if (exampleNames.length === 0)
     return all.map((name) => join12(baseDir, name));
   const matched = all.filter((name) => exampleNames.includes(name));
@@ -247483,7 +247756,7 @@ async function clearEvalOutputs(dir, exampleNames = [], options = {}) {
   runSection({
     exampleDirs,
     clean: (exampleDir) => removeDirEntriesWithRetention(join12(exampleDir, "executions"), removeAll),
-    shouldCount: (exampleDir) => existsSync19(join12(exampleDir, "executions")),
+    shouldCount: (exampleDir) => existsSync20(join12(exampleDir, "executions")),
     successLabel: "Execution cleanup complete",
     scannedLabel: "examples scanned:",
     seenLabel: "runs seen:       ",
@@ -247495,7 +247768,7 @@ async function clearEvalOutputs(dir, exampleNames = [], options = {}) {
   runSection({
     exampleDirs,
     clean: (exampleDir) => removeJudgeSummaryFilesWithRetention(exampleDir, removeAll),
-    shouldCount: (exampleDir) => existsSync19(exampleDir),
+    shouldCount: (exampleDir) => existsSync20(exampleDir),
     successLabel: "Judge summary cleanup complete",
     scannedLabel: "examples scanned:     ",
     seenLabel: "summary files seen:   ",
@@ -247899,7 +248172,7 @@ function registerStepExecCommands(workflow) {
 
 // src/commands/workflow/templates.ts
 init_src();
-import { existsSync as existsSync20, promises as fs20 } from "node:fs";
+import { existsSync as existsSync21, promises as fs20 } from "node:fs";
 import { basename as basename4, resolve as resolve10 } from "node:path";
 function buildClient5(opts) {
   const config = resolveConfig(opts);
@@ -248080,7 +248353,7 @@ function registerTemplateCommands(parent) {
       filename = downloaded.filename;
     } else {
       const filePath = resolve10(templateArg);
-      if (!existsSync20(filePath)) {
+      if (!existsSync21(filePath)) {
         throw new Error(`Template file not found: ${filePath}. Pass a local .docx/.xlsx path or a tmpl_… id.`);
       }
       bytes = await fs20.readFile(filePath);
@@ -248122,12 +248395,12 @@ function registerTemplateCommands(parent) {
 
 // src/commands/workflow/validation.ts
 init_src();
-import { existsSync as existsSync22, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync8, readFileSync as readFileSync20, statSync as statSync7 } from "fs";
 import { join as join13, resolve as resolve11 } from "path";
 
 // src/lib/template-diagnostics.ts
 init_src();
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "node:fs";
 function walkSteps(steps, pathPrefix, visit) {
   if (!Array.isArray(steps))
     return;
@@ -248252,7 +248525,7 @@ async function diagnoseTemplateSteps(args) {
         });
         continue;
       }
-      if (!existsSync21(absolute)) {
+      if (!existsSync22(absolute)) {
         diagnostics.push({
           field: `${info.fieldPath}.template`,
           message: `File not found: ${absolute}`,
@@ -248261,7 +248534,7 @@ async function diagnoseTemplateSteps(args) {
         continue;
       }
       try {
-        const bytes = readFileSync18(absolute);
+        const bytes = readFileSync19(absolute);
         const inspection = inspectOfficeTemplateBytes(bytes, absolute);
         diagnostics.push(...formatDiagnostics(info, inspection));
       } catch (err) {
@@ -248397,7 +248670,7 @@ function countInvokeWorkflowSteps(steps) {
   return count;
 }
 function validateWorkflowYaml(path) {
-  if (!existsSync22(path)) {
+  if (!existsSync23(path)) {
     return {
       issues: [{ field: path, message: "File not found." }],
       warnings: [],
@@ -248406,7 +248679,7 @@ function validateWorkflowYaml(path) {
       steps: []
     };
   }
-  const text = readFileSync19(path, "utf-8");
+  const text = readFileSync20(path, "utf-8");
   try {
     const definition = parseWorkflow(text);
     let warnings = [];
@@ -248507,10 +248780,10 @@ function printSchemaQualityWarnings(path, warnings) {
   }
 }
 function validateEvaluatorsYaml(path) {
-  if (!existsSync22(path)) {
+  if (!existsSync23(path)) {
     return [{ field: path, message: "File not found." }];
   }
-  const text = readFileSync19(path, "utf-8");
+  const text = readFileSync20(path, "utf-8");
   let parsed;
   try {
     parsed = $parse(text);
@@ -248527,21 +248800,21 @@ function validateEvaluatorsYaml(path) {
 }
 function validateDatasetFolder(root) {
   const issues = [];
-  if (!existsSync22(root)) {
+  if (!existsSync23(root)) {
     return [{ field: root, message: "Folder not found." }];
   }
-  if (existsSync22(join13(root, "manifest.json"))) {
+  if (existsSync23(join13(root, "manifest.json"))) {
     issues.push({
       field: "manifest.json",
       message: "Top-level manifest.json is the legacy format. Re-export the dataset using the folder convention."
     });
   }
   const examplesDir = join13(root, "examples");
-  if (!existsSync22(examplesDir)) {
+  if (!existsSync23(examplesDir)) {
     issues.push({ field: "examples/", message: "No examples/ directory found at dataset root." });
     return issues;
   }
-  for (const exampleName of readdirSync7(examplesDir)) {
+  for (const exampleName of readdirSync8(examplesDir)) {
     const exampleFolder = join13(examplesDir, exampleName);
     if (!isDirSafe(exampleFolder, issues, `examples/${exampleName}`))
       continue;
@@ -248553,7 +248826,7 @@ function validateDatasetFolder(root) {
       continue;
     }
     const inputJsonPath = join13(exampleFolder, "input.json");
-    const hasInputJson = existsSync22(inputJsonPath);
+    const hasInputJson = existsSync23(inputJsonPath);
     if (!hasInputJson) {
       issues.push({
         field: `examples/${exampleName}/input.json`,
@@ -248563,7 +248836,7 @@ function validateDatasetFolder(root) {
     }
     let args;
     try {
-      const parsed = JSON.parse(readFileSync19(inputJsonPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync20(inputJsonPath, "utf-8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         issues.push({
           field: `examples/${exampleName}/input.json`,
@@ -248580,7 +248853,7 @@ function validateDatasetFolder(root) {
       continue;
     }
     const inputDir = join13(exampleFolder, "input");
-    if (existsSync22(join13(inputDir, "arguments.json"))) {
+    if (existsSync23(join13(inputDir, "arguments.json"))) {
       issues.push({
         field: `examples/${exampleName}/input/arguments.json`,
         message: "Legacy input/arguments.json is no longer accepted. Use input.json instead."
@@ -248597,8 +248870,8 @@ function validateDatasetFolder(root) {
     }
     const expectedDir = join13(exampleFolder, "expected");
     const expectedJsonPath = join13(exampleFolder, "expected.json");
-    if (existsSync22(expectedDir)) {
-      for (const entry of readdirSync7(expectedDir)) {
+    if (existsSync23(expectedDir)) {
+      for (const entry of readdirSync8(expectedDir)) {
         if (entry === "output.json" || entry === "error.json") {
           issues.push({
             field: `examples/${exampleName}/expected/${entry}`,
@@ -248633,10 +248906,10 @@ function validateDatasetFolder(root) {
         }
       }
     }
-    if (existsSync22(expectedJsonPath)) {
+    if (existsSync23(expectedJsonPath)) {
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync19(expectedJsonPath, "utf-8"));
+        parsed = JSON.parse(readFileSync20(expectedJsonPath, "utf-8"));
       } catch {
         issues.push({
           field: `examples/${exampleName}/expected.json`,
@@ -248719,7 +248992,7 @@ function validateFileRefs2(args) {
       });
       continue;
     }
-    if (!existsSync22(join13(args.filesRoot, relative))) {
+    if (!existsSync23(join13(args.filesRoot, relative))) {
       issues.push({
         field: `${args.fieldPrefix}:${ref.jsonPath}`,
         message: `Referenced file does not exist: ${ref.path}.`
@@ -248751,7 +249024,7 @@ async function onlineInvokeIssues(yamlText, opts) {
 }
 function discoverWorkflowProjectRoots(rootPath) {
   const root = resolve11(rootPath);
-  if (existsSync22(join13(root, "workflow.yaml")))
+  if (existsSync23(join13(root, "workflow.yaml")))
     return [root];
   const candidates = [
     join13(root, "eigenpal", "workflows"),
@@ -248759,9 +249032,9 @@ function discoverWorkflowProjectRoots(rootPath) {
     root.endsWith(join13("eigenpal", "workflows")) ? root : ""
   ].filter(Boolean);
   for (const parent of candidates) {
-    if (!existsSync22(parent) || !statSync7(parent).isDirectory())
+    if (!existsSync23(parent) || !statSync7(parent).isDirectory())
       continue;
-    const projects = readdirSync7(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && existsSync22(join13(parent, entry.name, "workflow.yaml"))).map((entry) => join13(parent, entry.name)).sort();
+    const projects = readdirSync8(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && existsSync23(join13(parent, entry.name, "workflow.yaml"))).map((entry) => join13(parent, entry.name)).sort();
     if (projects.length > 0)
       return projects;
   }
@@ -248778,10 +249051,10 @@ async function validateProjectRoot(root, opts) {
   }
   const evOk = printIssues("evaluators.yaml", relPath(root, join13(root, "evaluators.yaml")), validateEvaluatorsYaml(join13(root, "evaluators.yaml")));
   const dsOk = printIssues("dataset/", relPath(root, join13(root, "dataset")), validateDatasetFolder(join13(root, "dataset")));
-  const templateOk = wfOk && existsSync22(wfFile) ? await runTemplateDiagnostics(wfFile, wfResult.steps, opts) : true;
+  const templateOk = wfOk && existsSync23(wfFile) ? await runTemplateDiagnostics(wfFile, wfResult.steps, opts) : true;
   let onlineOk = true;
-  if (wfOk && opts.online && existsSync22(wfFile)) {
-    onlineOk = printIssues("invoke refs (server)", wfPath, await onlineInvokeIssues(readFileSync19(wfFile, "utf-8"), opts));
+  if (wfOk && opts.online && existsSync23(wfFile)) {
+    onlineOk = printIssues("invoke refs (server)", wfPath, await onlineInvokeIssues(readFileSync20(wfFile, "utf-8"), opts));
   }
   return wfOk && evOk && dsOk && templateOk && onlineOk;
 }
@@ -248797,7 +249070,7 @@ Note
 ` + `  project unless you pass --allow-external-templates.
 `);
   withBaseUrl(cmd).action(action(async (path, opts) => {
-    if (path && (!existsSync22(resolve11(path)) || !statSync7(resolve11(path)).isDirectory())) {
+    if (path && (!existsSync23(resolve11(path)) || !statSync7(resolve11(path)).isDirectory())) {
       const target = resolve11(path);
       const wfResult = validateWorkflowYaml(target);
       const wfOk = printIssues("workflow.yaml", target, wfResult.issues);
@@ -248808,7 +249081,7 @@ Note
       const templateOk = wfOk ? await runTemplateDiagnostics(target, wfResult.steps, opts) : true;
       let onlineOk = true;
       if (wfOk && opts.online) {
-        onlineOk = printIssues("invoke refs (server)", target, await onlineInvokeIssues(readFileSync19(target, "utf-8"), opts));
+        onlineOk = printIssues("invoke refs (server)", target, await onlineInvokeIssues(readFileSync20(target, "utf-8"), opts));
       }
       if (!wfOk || !templateOk || !onlineOk)
         process.exit(1);
@@ -249065,7 +249338,7 @@ new uploads are deleted. The file on disk is not rewritten.
           defaultValue: "workflow.yaml",
           validate: (value) => {
             const p = value || "workflow.yaml";
-            if (!existsSync23(p))
+            if (!existsSync24(p))
               return `Not found: ${p}`;
             return;
           }
@@ -250081,7 +250354,7 @@ Behavior:
     const dest = opts.pull ? opts.pullOnComplete ?? `./results-${batchId}.${opts.format}` : null;
     if (dest) {
       const dir = path19.dirname(dest);
-      if (!existsSync23(dir)) {
+      if (!existsSync24(dir)) {
         error2(`Destination directory does not exist: ${dir}. Create it first or pass a path under an existing directory.`);
         process.exit(2);
       }