@cybernetyx1/atlasflow-runtime 0.1.0

package/dist/chunk-RF6W3TKJ.js

@@ -0,0 +1,2762 @@
+import {
+  createCwdSessionEnv,
+  makeFs,
+  virtualSandbox
+} from "./chunk-4DU4GJ2X.js";
+import {
+  inMemoryAdapter
+} from "./chunk-M4JW76IL.js";
+import {
+  createScopedSessionEnv,
+  mergeCommands
+} from "./chunk-S7RZJMCF.js";
+import {
+  getRegisteredApiKey,
+  resolveRegisteredModel
+} from "./chunk-HO6QHSUS.js";
+
+// src/agent.ts
+function createAgent(initialize) {
+  return { __atlasflowAgent: true, initialize };
+}
+function defineAgent(definition) {
+  return typeof definition === "function" ? createAgent(definition) : createAgent(() => definition);
+}
+function isCreatedAgent(value) {
+  return typeof value === "object" && value !== null && value.__atlasflowAgent === true;
+}
+function defineAgentProfile(profile) {
+  return profile;
+}
+function applyProfile(config) {
+  const profile = config.profile;
+  if (!profile) return config;
+  return {
+    ...config,
+    model: config.model ?? profile.model,
+    instructions: config.instructions ?? profile.instructions,
+    tools: config.tools ?? profile.tools,
+    thinkingLevel: config.thinkingLevel ?? profile.thinkingLevel
+  };
+}
+
+// src/approval.ts
+var ToolApprovalRequiredError = class extends Error {
+  constructor(runId, approval) {
+    super(`Tool "${approval.tool}" is waiting for approval (${approval.id}).`);
+    this.runId = runId;
+    this.approval = approval;
+    this.name = "ToolApprovalRequiredError";
+  }
+  runId;
+  approval;
+  code = "tool_approval_required";
+  partialTranscript;
+};
+function isToolApprovalRequiredError(value) {
+  return value instanceof ToolApprovalRequiredError || typeof value === "object" && value !== null && value.code === "tool_approval_required";
+}
+function attachToolApprovalPartialTranscript(value, partial) {
+  if (!isToolApprovalRequiredError(value)) return;
+  value.partialTranscript = partial;
+}
+function toolApprovalPartialTranscript(value) {
+  return isToolApprovalRequiredError(value) ? value.partialTranscript : void 0;
+}
+function normalizeToolApprovalPolicy(value) {
+  if (value === true) return { required: true };
+  if (value && value.required) return value;
+  return void 0;
+}
+function waitingToolApproval(record2) {
+  const state = toolApprovalState(record2.state);
+  if (!state || record2.status !== "waiting_approval") return void 0;
+  const pending = state.pending ? state.approvals[state.pending] : void 0;
+  if (pending?.status === "pending") return pending;
+  return Object.values(state.approvals).find((approval) => approval.status === "pending");
+}
+function decideToolApprovalState(record2, decision) {
+  const state = toolApprovalState(record2.state);
+  if (!state) throw new Error(`Run "${record2.runId}" is not waiting on a tool approval.`);
+  const approval = decision.approval ? state.approvals[decision.approval] : waitingToolApproval(record2);
+  if (!approval) throw new Error(`Run "${record2.runId}" has no pending tool approval.`);
+  if (approval.status !== "pending") throw new Error(`Approval "${approval.id}" is already ${approval.status}.`);
+  const decided = {
+    ...approval,
+    status: decision.approved ? "approved" : "rejected",
+    decidedAt: Date.now(),
+    resumeOnNextCall: decision.approved ? true : void 0,
+    note: decision.note
+  };
+  state.approvals[approval.id] = decided;
+  if (state.pending === approval.id) state.pending = void 0;
+  return { state, approval: decided };
+}
+function wrapToolApproval(tool, input) {
+  const policy = normalizeToolApprovalPolicy(tool.approval);
+  if (!policy) return tool;
+  return {
+    ...tool,
+    approval: policy,
+    execute: async (args, signal) => {
+      const record2 = await input.persistence.runs.get(input.runId);
+      if (!record2) throw new Error(`Run "${input.runId}" was not found while checking tool approval.`);
+      const next = await nextToolApproval(record2, tool, args, policy);
+      await input.persistence.runs.update(input.runId, { status: next.status, state: next.state });
+      if (next.action === "reject") throw new Error(`Tool "${tool.name}" was rejected${next.approval.note ? `: ${next.approval.note}` : "."}`);
+      if (next.action === "request") {
+        input.bus.emit({
+          type: "tool_approval_requested",
+          approval: next.approval.id,
+          tool: tool.name,
+          arguments: args,
+          runId: input.runId
+        });
+        throw new ToolApprovalRequiredError(input.runId, next.approval);
+      }
+      input.bus.emit({ type: "tool_approval_decided", approval: next.approval.id, tool: tool.name, approved: true, runId: input.runId });
+      return tool.execute(next.approval.arguments, signal);
+    }
+  };
+}
+async function nextToolApproval(record2, tool, args, policy) {
+  const state = ensureToolApprovalState(record2.state);
+  const canonicalCall = stableJson({ tool: tool.name, args });
+  const baseId = await toolApprovalBaseId(canonicalCall);
+  const existing = Object.values(state.approvals).filter((approval) => approvalMatchesCall(approval, tool.name, args, canonicalCall) && !approval.consumedAt).sort((a, b) => a.requestedAt - b.requestedAt)[0];
+  if (existing?.status === "approved") {
+    const consumed = { ...existing, consumedAt: Date.now(), resumeOnNextCall: void 0 };
+    state.approvals[existing.id] = consumed;
+    if (state.pending === existing.id) state.pending = void 0;
+    return { action: "execute", status: "running", state, approval: consumed };
+  }
+  if (existing?.status === "rejected") return { action: "reject", status: "failed", state, approval: existing };
+  if (existing?.status === "pending") {
+    state.pending = existing.id;
+    return { action: "request", status: "waiting_approval", state, approval: existing };
+  }
+  const resumable = Object.values(state.approvals).filter((approval) => approval.tool === tool.name && approval.status === "approved" && approval.resumeOnNextCall && !approval.consumedAt).sort((a, b) => (a.decidedAt ?? a.requestedAt) - (b.decidedAt ?? b.requestedAt))[0];
+  if (resumable) {
+    const consumed = { ...resumable, consumedAt: Date.now(), resumeOnNextCall: void 0 };
+    state.approvals[resumable.id] = consumed;
+    if (state.pending === resumable.id) state.pending = void 0;
+    return { action: "execute", status: "running", state, approval: consumed };
+  }
+  const ordinal = Object.values(state.approvals).filter((approval) => approvalMatchesCall(approval, tool.name, args, canonicalCall)).length + 1;
+  const requested = {
+    id: `${baseId}.${ordinal}`,
+    baseId,
+    tool: tool.name,
+    arguments: args,
+    reason: policy.reason,
+    status: "pending",
+    requestedAt: Date.now()
+  };
+  state.approvals[requested.id] = requested;
+  state.pending = requested.id;
+  return { action: "request", status: "waiting_approval", state, approval: requested };
+}
+function ensureToolApprovalState(value) {
+  const existing = toolApprovalState(value);
+  if (existing) return existing;
+  return { kind: "tool_approval", approvals: {} };
+}
+function toolApprovalState(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (candidate.kind !== "tool_approval" || !candidate.approvals || typeof candidate.approvals !== "object") return void 0;
+  return { kind: "tool_approval", approvals: { ...candidate.approvals }, pending: typeof candidate.pending === "string" ? candidate.pending : void 0 };
+}
+function approvalMatchesCall(approval, tool, args, canonicalCall = stableJson({ tool, args })) {
+  return approval.tool === tool && stableJson({ tool: approval.tool, args: approval.arguments }) === canonicalCall;
+}
+async function toolApprovalBaseId(canonicalCall) {
+  return `tap_sha256_${await sha256Hex(canonicalCall)}`;
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableJson(obj[key])}`).join(",")}}`;
+}
+async function sha256Hex(value) {
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi?.subtle) throw new Error("Tool approval hashing requires Web Crypto SHA-256 support.");
+  const digest = await cryptoApi.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/builtin-tools.ts
+var DEFAULT_MAX_OUTPUT = 5e4;
+function builtinTools(env, options = {}) {
+  const cap = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
+  const all = [
+    readTool(env, cap),
+    writeTool(env),
+    editTool(env),
+    bashTool(env, cap),
+    grepTool(env, cap),
+    globTool(env, cap)
+  ];
+  if (!options.include) return all;
+  const include = new Set(options.include);
+  return all.filter((t) => include.has(t.name));
+}
+var BUILTIN_TOOL_NAMES = ["read", "write", "edit", "bash", "grep", "glob", "task"];
+function truncate(text, cap) {
+  if (text.length <= cap) return text;
+  return `${text.slice(0, cap)}
+... [output truncated at ${cap} characters]`;
+}
+function readTool(env, cap) {
+  return {
+    name: "read",
+    description: "Read a file from the workspace. Returns the file content (optionally a line range).",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path (absolute, or relative to the workspace)." },
+        offset: { type: "number", description: "1-based line to start from (optional)." },
+        limit: { type: "number", description: "Max lines to return (optional)." }
+      },
+      required: ["path"]
+    },
+    execute: async (args) => {
+      const path = String(args.path);
+      const content = await env.readFile(path);
+      if (args.offset == null && args.limit == null) return truncate(content, cap);
+      const lines = content.split("\n");
+      const start = Math.max(0, (Number(args.offset) || 1) - 1);
+      const count = args.limit != null ? Number(args.limit) : lines.length - start;
+      return truncate(lines.slice(start, start + count).join("\n"), cap);
+    }
+  };
+}
+function writeTool(env) {
+  return {
+    name: "write",
+    description: "Write a file in the workspace, creating parent directories and overwriting any existing content.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path (absolute, or relative to the workspace)." },
+        content: { type: "string", description: "Full file content to write." }
+      },
+      required: ["path", "content"]
+    },
+    execute: async (args) => {
+      const path = String(args.path);
+      const content = String(args.content);
+      const dir = dirnameOf(env.resolvePath(path));
+      if (dir) await env.mkdir(dir, { recursive: true }).catch(() => {
+      });
+      await env.writeFile(path, content);
+      return `Wrote ${content.length} characters to ${path}`;
+    }
+  };
+}
+function editTool(env) {
+  return {
+    name: "edit",
+    description: "Replace an exact string in a file. The old string must match exactly and be unique unless replace_all is true.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path (absolute, or relative to the workspace)." },
+        old_string: { type: "string", description: "Exact text to find." },
+        new_string: { type: "string", description: "Replacement text." },
+        replace_all: { type: "boolean", description: "Replace every occurrence (default false)." }
+      },
+      required: ["path", "old_string", "new_string"]
+    },
+    execute: async (args) => {
+      const path = String(args.path);
+      const oldStr = String(args.old_string);
+      const newStr = String(args.new_string);
+      if (oldStr === newStr) throw new Error("old_string and new_string are identical");
+      if (oldStr === "") throw new Error("old_string must not be empty");
+      const content = await env.readFile(path);
+      const count = content.split(oldStr).length - 1;
+      if (count === 0) throw new Error(`old_string not found in ${path}`);
+      if (count > 1 && args.replace_all !== true)
+        throw new Error(`old_string appears ${count} times in ${path}; include more surrounding context to make it unique, or set replace_all`);
+      const updated = args.replace_all === true ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+      await env.writeFile(path, updated);
+      return `Edited ${path} (${count} replacement${count === 1 ? "" : "s"})`;
+    }
+  };
+}
+function bashTool(env, cap) {
+  return {
+    name: "bash",
+    description: "Run a shell command in the workspace and return stdout, stderr, and the exit code. Some providers, including the default virtual sandbox, are lightweight and may not include python3, node, git, or system packages; if a command exits non-zero, treat it as failed and do not infer missing output.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run." },
+        timeout_ms: { type: "number", description: "Timeout in milliseconds (default 120000, max 600000)." },
+        cwd: { type: "string", description: "Working directory (optional)." }
+      },
+      required: ["command"]
+    },
+    execute: async (args, signal) => {
+      const timeoutMs = Math.min(Number(args.timeout_ms) || 12e4, 6e5);
+      const res = await env.exec(String(args.command), { timeoutMs, cwd: args.cwd ? String(args.cwd) : void 0, signal });
+      const parts = [];
+      if (res.exitCode !== 0) {
+        parts.push(`[command failed: exit code ${res.exitCode}] Do not infer or fabricate missing stdout; report the failure, stderr, and exit code.`);
+      }
+      if (res.stdout) parts.push(truncate(res.stdout, cap));
+      if (res.stderr) parts.push(`[stderr]
+${truncate(res.stderr, Math.min(cap, 1e4))}`);
+      parts.push(`[exit code: ${res.exitCode}]`);
+      return parts.join("\n");
+    }
+  };
+}
+function grepTool(env, cap) {
+  return {
+    name: "grep",
+    description: "Search file contents for a regular expression. Returns matching lines as path:line:text.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Regular expression (POSIX extended)." },
+        path: { type: "string", description: "File or directory to search (default: workspace root)." },
+        ignore_case: { type: "boolean", description: "Case-insensitive search (default false)." }
+      },
+      required: ["pattern"]
+    },
+    execute: async (args, signal) => {
+      const target = args.path ? String(args.path) : ".";
+      const flags = `-rnE${args.ignore_case === true ? "i" : ""}`;
+      const cmd = `grep ${flags} --exclude-dir=node_modules --exclude-dir=.git -- ${shq(String(args.pattern))} ${shq(target)}`;
+      const res = await env.exec(cmd, { timeoutMs: 6e4, signal });
+      if (res.exitCode > 1) throw new Error(res.stderr || `grep failed with exit code ${res.exitCode}`);
+      return res.stdout ? truncate(res.stdout, cap) : "No matches found.";
+    }
+  };
+}
+function globTool(env, cap) {
+  return {
+    name: "glob",
+    description: 'Find files by glob pattern (e.g. "**/*.ts", "src/*.json"). Returns matching paths.',
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Glob pattern. ** matches across directories." },
+        path: { type: "string", description: "Directory to search from (default: workspace root)." }
+      },
+      required: ["pattern"]
+    },
+    execute: async (args) => {
+      const base = args.path ? String(args.path) : ".";
+      const matcher = globToRegExp(String(args.pattern));
+      const found = [];
+      await walk(env, base, "", matcher, found, { visited: 0 });
+      return found.length ? truncate(found.sort().join("\n"), cap) : "No files matched.";
+    }
+  };
+}
+var WALK_LIMIT = 1e4;
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".atlasflow-build"]);
+async function walk(env, base, rel, matcher, found, budget) {
+  if (budget.visited >= WALK_LIMIT || found.length >= 2e3) return;
+  const dir = rel ? joinPath(base, rel) : base;
+  let entries;
+  try {
+    entries = await env.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (budget.visited++ >= WALK_LIMIT) return;
+    const childRel = rel ? `${rel}/${entry}` : entry;
+    let isDir = false;
+    try {
+      isDir = (await env.stat(joinPath(base, childRel))).isDirectory;
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      if (!SKIP_DIRS.has(entry)) await walk(env, base, childRel, matcher, found, budget);
+    } else if (matcher.test(childRel)) {
+      found.push(childRel);
+    }
+  }
+}
+function joinPath(base, rel) {
+  return base === "." ? rel : `${base.replace(/\/$/, "")}/${rel}`;
+}
+function globToRegExp(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        out += pattern[i + 2] === "/" ? "(?:.*/)?" : ".*";
+        i += pattern[i + 2] === "/" ? 2 : 1;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else if (ch && ".+^${}()|[]\\".includes(ch)) {
+      out += `\\${ch}`;
+    } else {
+      out += ch;
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function dirnameOf(path) {
+  const idx = path.lastIndexOf("/");
+  if (idx <= 0) return null;
+  return path.slice(0, idx);
+}
+function shq(s) {
+  return `'${s.replace(/'/g, `'${String.fromCharCode(92)}''`)}'`;
+}
+
+// src/context.ts
+function isWorkspaceSkill(skill) {
+  const candidate = skill;
+  return candidate.__atlasWorkspaceSkill === true && typeof candidate.directory === "string" && typeof candidate.skillMdPath === "string";
+}
+async function discoverSessionContext(env, definitionSkills = []) {
+  const instructionFiles = await readInstructionFiles(env, env.cwd);
+  const workspaceSkills = await discoverWorkspaceSkills(env, env.cwd);
+  const names = new Set(definitionSkills.map((skill) => skill.name));
+  for (const skill of workspaceSkills) {
+    if (names.has(skill.name)) throw new Error(`Skill name "${skill.name}" appears in both the agent definition and workspace discovery.`);
+  }
+  const instructions = composeDiscoveredInstructions(instructionFiles, workspaceSkills);
+  return { instructions, workspaceSkills };
+}
+async function loadWorkspaceSkill(env, skill) {
+  const content = await env.readFile(skill.skillMdPath);
+  const parsed = parseSkillMarkdown(content, { directoryName: lastPathPart(skill.directory), path: skill.skillMdPath });
+  return parsed;
+}
+function composeDiscoveredInstructions(instructionFiles, workspaceSkills) {
+  const parts = [];
+  if (instructionFiles.length) parts.push(instructionFiles.join("\n\n"));
+  if (workspaceSkills.length) {
+    parts.push(
+      [
+        "## Available Skills",
+        "",
+        "The following workspace skills provide specialized instructions for specific tasks. When a task matches a skill description, call the `activate_skill` tool with that skill name before proceeding so its full instructions are loaded.",
+        "",
+        ...workspaceSkills.map((skill) => `- **${skill.name}**${skill.description ? ` - ${skill.description}` : ""}`)
+      ].join("\n")
+    );
+  }
+  return parts.length ? parts.join("\n\n") : void 0;
+}
+async function readInstructionFiles(env, basePath) {
+  const out = [];
+  for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
+    const filePath = joinPath2(basePath, filename);
+    if (await env.exists(filePath)) {
+      const content = (await env.readFile(filePath)).trim();
+      if (content) out.push(content);
+    }
+  }
+  return out;
+}
+async function discoverWorkspaceSkills(env, basePath) {
+  const skillsDir = joinPath2(basePath, ".agents/skills");
+  if (!await env.exists(skillsDir)) return [];
+  let entries;
+  try {
+    entries = await env.readdir(skillsDir);
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort()) {
+    const skillDir = joinPath2(skillsDir, entry);
+    try {
+      const stat = await env.stat(skillDir);
+      if (!stat.isDirectory) continue;
+    } catch {
+      continue;
+    }
+    const skillMdPath = joinPath2(skillDir, "SKILL.md");
+    if (!await env.exists(skillMdPath)) continue;
+    try {
+      const parsed = parseSkillMarkdown(await env.readFile(skillMdPath), { directoryName: entry, path: skillMdPath });
+      skills.push({
+        __atlasWorkspaceSkill: true,
+        name: parsed.name,
+        description: parsed.description,
+        body: "",
+        allowedTools: parsed.allowedTools,
+        directory: skillDir,
+        skillMdPath
+      });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      console.warn(`[atlasflow] Skipping invalid workspace skill "${entry}": ${detail}`);
+    }
+  }
+  return skills;
+}
+function parseSkillMarkdown(content, options) {
+  const match = content.replace(/^\uFEFF/, "").match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)([\s\S]*)$/);
+  if (!match) throw new Error(`Skill ${options.path} is missing YAML frontmatter with name and description.`);
+  const frontmatter = parseSimpleYamlMapping(match[1] ?? "", options.path);
+  const name = requireString(frontmatter.name, options.path, "name");
+  validateSkillName(name, options);
+  const description = requireString(frontmatter.description, options.path, "description");
+  if ([...description].length > 1024) throw new Error(`Skill ${options.path} description exceeds 1024 characters.`);
+  return {
+    name,
+    description,
+    body: (match[2] ?? "").trim(),
+    allowedTools: optionalString(frontmatter["allowed-tools"], options.path, "allowed-tools")?.split(/\s+/).filter(Boolean)
+  };
+}
+function parseSimpleYamlMapping(source, path) {
+  const out = {};
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const idx = line.indexOf(":");
+    if (idx <= 0) throw new Error(`Skill ${path} frontmatter must be a simple YAML mapping.`);
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+    out[key] = value;
+  }
+  return out;
+}
+function requireString(value, path, field) {
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`Skill ${path} must define frontmatter ${field} as a non-empty string.`);
+  return value.trim();
+}
+function optionalString(value, path, field) {
+  if (value == null) return void 0;
+  if (typeof value !== "string") throw new Error(`Skill ${path} frontmatter ${field} must be a string when provided.`);
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function validateSkillName(name, options) {
+  const normalized = name.normalize("NFKC");
+  if ([...normalized].length > 64) throw new Error(`Skill ${options.path} name must be at most 64 characters.`);
+  if (!/^[\p{L}\p{N}-]+$/u.test(normalized) || normalized !== normalized.toLowerCase()) {
+    throw new Error(`Skill ${options.path} name "${name}" must contain only lowercase letters, numbers, and hyphens.`);
+  }
+  if (normalized.startsWith("-") || normalized.endsWith("-") || normalized.includes("--")) {
+    throw new Error(`Skill ${options.path} name "${name}" must not start or end with a hyphen or contain consecutive hyphens.`);
+  }
+  if (normalized !== options.directoryName.normalize("NFKC")) {
+    throw new Error(`Skill ${options.path} declares name "${name}", but the directory is "${options.directoryName}".`);
+  }
+}
+function joinPath2(base, child) {
+  return `${base.replace(/\/$/, "")}/${child}`;
+}
+function lastPathPart(path) {
+  return path.replace(/\/+$/, "").split("/").pop() ?? path;
+}
+
+// src/rules.ts
+var RuleViolation = class extends Error {
+  constructor(rule, message) {
+    super(message);
+    this.rule = rule;
+    this.name = "RuleViolation";
+  }
+  rule;
+  code = "rule_violation";
+};
+function matches(rule, toolName, subject) {
+  if (rule.tools && toolName !== void 0 && !rule.tools.includes(toolName)) return false;
+  if (rule.pattern !== void 0) {
+    try {
+      return new RegExp(rule.pattern, "i").test(subject);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function makeRuleGuard(rules, hooks, bus, runId) {
+  const at = (point) => rules.filter((r) => r.enforce === point);
+  const fire = (rule, point) => {
+    bus.emit({ type: "rule_triggered", rule: rule.name, point, action: rule.action ?? "block", runId });
+  };
+  async function decide(decision, label) {
+    const d = await decision;
+    if (d && !d.allow) throw new RuleViolation(label, d.message);
+  }
+  return {
+    async checkPrompt(text) {
+      for (const rule of at("before_prompt")) {
+        if (!matches(rule, void 0, text)) continue;
+        fire(rule, "before_prompt");
+        if ((rule.action ?? "block") === "block") throw new RuleViolation(rule.name, rule.message);
+      }
+      await decide(hooks?.beforePrompt?.(text), "beforePrompt hook");
+    },
+    wrapTool(tool) {
+      return {
+        ...tool,
+        execute: async (args, signal) => {
+          const argsText = JSON.stringify(args);
+          for (const rule of at("before_tool")) {
+            if (!matches(rule, tool.name, argsText)) continue;
+            fire(rule, "before_tool");
+            if ((rule.action ?? "block") === "block") throw new RuleViolation(rule.name, rule.message);
+          }
+          await decide(hooks?.beforeTool?.(tool.name, args), "beforeTool hook");
+          const result = await tool.execute(args, signal);
+          for (const rule of at("after_tool")) {
+            if (!matches(rule, tool.name, result)) continue;
+            fire(rule, "after_tool");
+            if ((rule.action ?? "block") === "block") throw new RuleViolation(rule.name, rule.message);
+          }
+          await decide(hooks?.afterTool?.(tool.name, result), "afterTool hook");
+          return result;
+        }
+      };
+    }
+  };
+}
+
+// src/types.ts
+function emptyUsage() {
+  return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0, costTotal: 0 };
+}
+function addUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    costTotal: a.costTotal + b.costTotal
+  };
+}
+
+// src/engine-pi.ts
+import {
+  getEnvApiKey,
+  getModel,
+  registerBuiltInApiProviders,
+  stream
+} from "@earendil-works/pi-ai";
+var providersReady = false;
+function ensureProviders() {
+  if (!providersReady) {
+    registerBuiltInApiProviders();
+    providersReady = true;
+  }
+}
+var MAX_ITERATIONS = 50;
+var PiAgentEngine = class {
+  async run(input, hooks) {
+    const { provider, modelId } = splitModel(input.model);
+    if (provider === "cloudflare") {
+      return runCloudflareAiBinding(input, hooks, modelId);
+    }
+    ensureProviders();
+    const override = input.providers?.[provider];
+    let model = resolveModel(provider, modelId, override);
+    model = applyProviderRuntimeSettings(model, override, input.env);
+    const registeredApiKey = getRegisteredApiKey(provider);
+    const apiKey = input.apiKey ?? override?.apiKey ?? registeredApiKey ?? envApiKeyFor(provider, input.env) ?? getEnvApiKey(provider);
+    const keyEnvNames = providerApiKeyEnvNames(provider);
+    if (!apiKey && requiresHostedProviderApiKey(provider, override, registeredApiKey)) {
+      const message2 = providerKeyMissingMessage(provider, input.model, keyEnvNames);
+      hooks.bus.emit({ type: "run_error", code: "provider_api_key_missing", message: message2, runId: hooks.runId, session: hooks.session });
+      throw new EngineError("provider_api_key_missing", message2);
+    }
+    const context = {
+      systemPrompt: input.instructions,
+      messages: input.messages.map((m) => toPiMessage(m, model)),
+      tools: input.tools.map(toPiTool)
+    };
+    const options = {
+      apiKey,
+      signal: input.signal,
+      sessionId: input.sessionId,
+      cacheRetention: input.cacheRetention ?? "short",
+      ...thinkingOptions(input.thinkingLevel)
+    };
+    const toolMap = new Map(input.tools.map((t) => [t.name, t]));
+    const appended = [];
+    let totalUsage = emptyUsage();
+    let finalText = "";
+    await resumePendingPiToolCalls(input.messages, toolMap, input.signal, hooks, context, appended, () => totalUsage);
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+      const turnId = `turn_${iteration}`;
+      hooks.bus.emit({ type: "turn_start", turnId, model: input.model, runId: hooks.runId, session: hooks.session });
+      let assistant;
+      try {
+        const handle = stream(model, context, options);
+        for await (const ev of handle) {
+          if (ev.type === "text_delta") {
+            hooks.bus.emit({ type: "text_delta", turnId, delta: ev.delta, runId: hooks.runId, session: hooks.session });
+          } else if (ev.type === "thinking_delta") {
+            hooks.bus.emit({ type: "thinking_delta", turnId, delta: ev.delta, runId: hooks.runId, session: hooks.session });
+          }
+        }
+        assistant = await handle.result();
+      } catch (err) {
+        const providerError = providerCredentialError(provider, input.model, keyEnvNames, err);
+        if (providerError) {
+          hooks.bus.emit({ type: "run_error", code: providerError.code, message: providerError.message, runId: hooks.runId, session: hooks.session });
+          throw providerError;
+        }
+        const message2 = err instanceof Error ? err.message : String(err);
+        hooks.bus.emit({ type: "run_error", code: "model_call_failed", message: message2, runId: hooks.runId, session: hooks.session });
+        throw new EngineError("model_call_failed", message2);
+      }
+      if (assistant.stopReason === "error") {
+        const message2 = assistant.errorMessage ?? "model returned an error";
+        const providerError = providerCredentialError(provider, input.model, keyEnvNames, message2);
+        if (providerError) {
+          hooks.bus.emit({ type: "run_error", code: providerError.code, message: providerError.message, runId: hooks.runId, session: hooks.session });
+          throw providerError;
+        }
+        hooks.bus.emit({ type: "run_error", code: "model_error", message: message2, runId: hooks.runId, session: hooks.session });
+        throw new EngineError("model_error", message2);
+      }
+      context.messages.push(assistant);
+      const ourAssistant = fromPiAssistant(assistant);
+      appended.push(ourAssistant);
+      totalUsage = addPiUsage(totalUsage, assistant.usage);
+      hooks.bus.emit({
+        type: "turn_end",
+        turnId,
+        usage: mapUsage(assistant.usage),
+        stopReason: assistant.stopReason,
+        runId: hooks.runId,
+        session: hooks.session
+      });
+      finalText = textOf(ourAssistant);
+      const toolCalls = assistant.content.filter((c) => c.type === "toolCall");
+      if (toolCalls.length === 0 || assistant.stopReason !== "toolUse") {
+        return { appended, text: finalText, usage: totalUsage };
+      }
+      for (const call of toolCalls) {
+        await runPiToolCall(call, toolMap, input.signal, hooks, context, appended, () => totalUsage);
+      }
+    }
+    const message = `agent loop exceeded ${MAX_ITERATIONS} iterations without finishing`;
+    hooks.bus.emit({ type: "run_error", code: "max_iterations", message, runId: hooks.runId, session: hooks.session });
+    throw new EngineError("max_iterations", message);
+  }
+};
+async function runCloudflareAiBinding(input, hooks, modelId) {
+  const ai = workersAiBinding(input.env);
+  if (!ai) {
+    const message2 = 'Cloudflare Workers AI binding unavailable. Models prefixed with "cloudflare/" require a Worker env.AI binding; use "cloudflare-workers-ai/" for HTTP/API-token access.';
+    hooks.bus.emit({ type: "run_error", code: "workers_ai_binding_unavailable", message: message2, runId: hooks.runId, session: hooks.session });
+    throw new EngineError("workers_ai_binding_unavailable", message2);
+  }
+  const toolMap = new Map(input.tools.map((t) => [t.name, t]));
+  const appended = [];
+  const messages = toWorkersAiMessages(input.instructions, input.messages);
+  let totalUsage = emptyUsage();
+  let finalText = "";
+  await resumePendingWorkersToolCalls(input.messages, toolMap, input.signal, hooks, messages, appended, () => totalUsage);
+  for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+    const turnId = `turn_${iteration}`;
+    hooks.bus.emit({ type: "turn_start", turnId, model: input.model, runId: hooks.runId, session: hooks.session });
+    let parsed;
+    try {
+      const raw = await ai.run(
+        modelId,
+        {
+          messages,
+          ...input.tools.length ? { tools: input.tools.map(toWorkersAiTool), tool_choice: workersAiToolChoice(input.toolChoice, messages), parallel_tool_calls: true } : {}
+        },
+        { signal: input.signal }
+      );
+      parsed = await parseWorkersAiResponse(raw);
+    } catch (err) {
+      const message2 = err instanceof Error ? err.message : String(err);
+      hooks.bus.emit({ type: "run_error", code: "workers_ai_binding_failed", message: message2, runId: hooks.runId, session: hooks.session });
+      throw new EngineError("workers_ai_binding_failed", message2);
+    }
+    totalUsage = addUsage(totalUsage, parsed.usage);
+    if (parsed.text) hooks.bus.emit({ type: "text_delta", turnId, delta: parsed.text, runId: hooks.runId, session: hooks.session });
+    const assistant = {
+      role: "assistant",
+      content: [
+        ...parsed.text ? [{ type: "text", text: parsed.text }] : [],
+        ...parsed.toolCalls.map((call) => ({ type: "tool_call", id: call.id, name: call.name, arguments: call.arguments }))
+      ],
+      usage: parsed.usage,
+      stopReason: parsed.toolCalls.length ? "tool_use" : parsed.stopReason
+    };
+    appended.push(assistant);
+    messages.push(toWorkersAiAssistantMessage(parsed));
+    finalText = parsed.text;
+    hooks.bus.emit({
+      type: "turn_end",
+      turnId,
+      usage: parsed.usage,
+      stopReason: parsed.toolCalls.length ? "tool_use" : parsed.stopReason,
+      runId: hooks.runId,
+      session: hooks.session
+    });
+    if (!parsed.toolCalls.length) return { appended, text: finalText, usage: totalUsage };
+    for (const call of parsed.toolCalls) {
+      await runWorkersToolCall(call, toolMap, input.signal, hooks, messages, appended, () => totalUsage);
+    }
+  }
+  const message = `Workers AI binding agent loop exceeded ${MAX_ITERATIONS} iterations without finishing`;
+  hooks.bus.emit({ type: "run_error", code: "max_iterations", message, runId: hooks.runId, session: hooks.session });
+  throw new EngineError("max_iterations", message);
+}
+function envApiKeyFor(provider, env) {
+  if (!env) return void 0;
+  for (const name of providerApiKeyEnvNames(provider)) {
+    const value = env[name];
+    if (typeof value === "string" && value) return value;
+  }
+  return void 0;
+}
+function providerApiKeyEnvNames(provider) {
+  const names = {
+    anthropic: ["ANTHROPIC_API_KEY"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    "cloudflare-workers-ai": ["CLOUDFLARE_API_KEY"],
+    "cloudflare-ai-gateway": ["CLOUDFLARE_API_KEY"],
+    groq: ["GROQ_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"],
+    xai: ["XAI_API_KEY"],
+    mistral: ["MISTRAL_API_KEY"],
+    cerebras: ["CEREBRAS_API_KEY"]
+  };
+  return names[provider] ?? [`${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`];
+}
+var HOSTED_PROVIDERS_REQUIRING_API_KEYS = /* @__PURE__ */ new Set([
+  "anthropic",
+  "openai",
+  "google",
+  "cloudflare-workers-ai",
+  "cloudflare-ai-gateway",
+  "groq",
+  "openrouter",
+  "xai",
+  "mistral",
+  "cerebras"
+]);
+function requiresHostedProviderApiKey(provider, settings, registeredApiKey) {
+  if (registeredApiKey) return false;
+  if (!HOSTED_PROVIDERS_REQUIRING_API_KEYS.has(provider)) return false;
+  if (settings?.baseUrl || settings?.api || settings?.models) return false;
+  const headers = settings?.headers ?? {};
+  return !Object.keys(headers).some((key) => key.toLowerCase() === "authorization" || key.toLowerCase() === "x-api-key");
+}
+function providerKeyMissingMessage(provider, model, envNames) {
+  const envList = envNames.join(" or ");
+  return `Model provider "${provider}" requires ${envList} for model "${model}". Set ${envNames[0]} in the environment or pass providers["${provider}"].apiKey.`;
+}
+function providerCredentialError(provider, model, envNames, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (!looksLikeProviderAuthError(message)) return void 0;
+  const envList = envNames.join(" or ");
+  return new EngineError(
+    "provider_api_key_rejected",
+    `Model provider "${provider}" rejected the API key for model "${model}". Check ${envList} or providers["${provider}"].apiKey.`
+  );
+}
+function looksLikeProviderAuthError(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("401") || normalized.includes("unauthorized") || normalized.includes("authentication_error") || normalized.includes("invalid_api_key") || normalized.includes("invalid x-api-key") || normalized.includes("invalid api key");
+}
+var EngineError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EngineError";
+  }
+  code;
+};
+function thinkingOptions(level) {
+  if (!level || level === "off") return {};
+  const effort = level === "minimal" ? "low" : level;
+  return { thinkingEnabled: true, effort };
+}
+async function runTool(tool, call, signal) {
+  if (!tool) return { text: `Error: unknown tool "${call.name}"`, isError: true };
+  try {
+    return { text: await tool.execute(call.arguments, signal), isError: false };
+  } catch (err) {
+    if (isToolApprovalRequiredError(err)) throw err;
+    return { text: `Error: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+  }
+}
+async function resumePendingPiToolCalls(messages, toolMap, signal, hooks, context, appended, usage) {
+  for (const call of pendingToolCalls(messages)) {
+    await runPiToolCall(call, toolMap, signal, hooks, context, appended, usage);
+  }
+}
+async function runPiToolCall(call, toolMap, signal, hooks, context, appended, usage) {
+  hooks.bus.emit({ type: "tool_call", tool: call.name, callId: call.id, arguments: call.arguments, runId: hooks.runId, session: hooks.session });
+  let ran;
+  try {
+    ran = await runTool(toolMap.get(call.name), call, signal);
+  } catch (err) {
+    attachToolApprovalPartialTranscript(err, { appended: [...appended], usage: usage() });
+    throw err;
+  }
+  const result = {
+    role: "toolResult",
+    toolCallId: call.id,
+    toolName: call.name,
+    content: [{ type: "text", text: ran.text }],
+    isError: ran.isError,
+    timestamp: Date.now()
+  };
+  context.messages.push(result);
+  appended.push({ role: "tool_result", toolCallId: call.id, toolName: call.name, content: [{ type: "text", text: ran.text }], isError: ran.isError });
+  hooks.bus.emit({ type: "tool_result", tool: call.name, callId: call.id, ok: !ran.isError, runId: hooks.runId, session: hooks.session });
+}
+async function resumePendingWorkersToolCalls(inputMessages, toolMap, signal, hooks, messages, appended, usage) {
+  for (const call of pendingToolCalls(inputMessages)) {
+    await runWorkersToolCall(call, toolMap, signal, hooks, messages, appended, usage);
+  }
+}
+async function runWorkersToolCall(call, toolMap, signal, hooks, messages, appended, usage) {
+  hooks.bus.emit({ type: "tool_call", tool: call.name, callId: call.id, arguments: call.arguments, runId: hooks.runId, session: hooks.session });
+  let ran;
+  try {
+    ran = await runTool(toolMap.get(call.name), call, signal);
+  } catch (err) {
+    attachToolApprovalPartialTranscript(err, { appended: [...appended], usage: usage() });
+    throw err;
+  }
+  const result = { role: "tool_result", toolCallId: call.id, toolName: call.name, content: [{ type: "text", text: ran.text }], isError: ran.isError };
+  appended.push(result);
+  messages.push({ role: "tool", tool_call_id: call.id, name: call.name, content: ran.text });
+  hooks.bus.emit({ type: "tool_result", tool: call.name, callId: call.id, ok: !ran.isError, runId: hooks.runId, session: hooks.session });
+}
+function pendingToolCalls(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.role === "tool_result") continue;
+    if (message.role !== "assistant") return [];
+    const calls = message.content.filter((part) => part.type === "tool_call").map((part) => ({ id: part.id, name: part.name, arguments: part.arguments }));
+    if (!calls.length) return [];
+    const resultIds = new Set(
+      messages.slice(index + 1).filter((candidate) => candidate.role === "tool_result").map((candidate) => candidate.toolCallId)
+    );
+    return calls.filter((call) => !resultIds.has(call.id));
+  }
+  return [];
+}
+function workersAiBinding(env) {
+  const ai = env?.AI;
+  return typeof ai === "object" && ai !== null && typeof ai.run === "function" ? ai : void 0;
+}
+function workersAiToolChoice(choice, messages) {
+  if (choice === "required") return messages.some((message) => message.role === "tool") ? "auto" : "required";
+  return choice ?? "auto";
+}
+function toWorkersAiMessages(instructions, messages) {
+  const out = [];
+  if (instructions) out.push({ role: "system", content: instructions });
+  for (const message of messages) {
+    if (message.role === "user") {
+      out.push({ role: "user", content: workersAiUserContent(message.content) });
+    } else if (message.role === "assistant") {
+      out.push(toWorkersAiAssistantMessage({
+        text: textOf(message),
+        toolCalls: message.content.filter((part) => part.type === "tool_call").map((part) => ({ id: part.id, name: part.name, arguments: part.arguments }))
+      }));
+    } else {
+      out.push({
+        role: "tool",
+        tool_call_id: message.toolCallId,
+        name: message.toolName,
+        content: message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")
+      });
+    }
+  }
+  return out;
+}
+function workersAiUserContent(content) {
+  const hasImage = content.some((part) => part.type === "image");
+  if (!hasImage) return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  return content.map((part) => {
+    if (part.type === "text") return { type: "text", text: part.text };
+    return { type: "image_url", image_url: { url: `data:${part.mimeType};base64,${part.data}` } };
+  });
+}
+function toWorkersAiAssistantMessage(parsed) {
+  return {
+    role: "assistant",
+    content: parsed.text || "",
+    ...parsed.toolCalls.length ? { tool_calls: parsed.toolCalls.map(toWorkersAiToolCallWire) } : {}
+  };
+}
+function toWorkersAiTool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+      strict: false
+    }
+  };
+}
+function toWorkersAiToolCallWire(call) {
+  return { id: call.id, type: "function", function: { name: call.name, arguments: JSON.stringify(call.arguments) } };
+}
+async function parseWorkersAiResponse(raw) {
+  const response = raw instanceof Response ? await raw.json().catch(() => ({})) : raw;
+  const body = objectValue(response) ?? {};
+  const result = objectValue(body.result) ?? body;
+  const choice = Array.isArray(result.choices) ? objectValue(result.choices[0]) : void 0;
+  const message = objectValue(choice?.message) ?? objectValue(choice?.delta);
+  const text = textFromWorkersAiContent(message?.content) ?? textFromWorkersAiContent(result.response) ?? textFromWorkersAiContent(result.text) ?? "";
+  const toolCalls = parseWorkersAiToolCalls(message?.tool_calls ?? choice?.tool_calls ?? result.tool_calls);
+  const usage = workersAiUsage(objectValue(result.usage) ?? objectValue(body.usage));
+  const stopReason = workersAiStopReason(choice?.finish_reason);
+  if (!text && toolCalls.length === 0) throw new Error(`Cloudflare AI binding returned no text or tool calls: ${safeJson(response)}`);
+  return { text, toolCalls, usage, stopReason };
+}
+function objectValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function textFromWorkersAiContent(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return void 0;
+  return value.map((part) => {
+    const obj = objectValue(part);
+    return obj?.type === "text" && typeof obj.text === "string" ? obj.text : "";
+  }).join("");
+}
+function parseWorkersAiToolCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry, index) => {
+    const obj = objectValue(entry);
+    if (!obj) return [];
+    const fn = objectValue(obj.function) ?? obj;
+    const name = typeof fn.name === "string" ? fn.name : void 0;
+    if (!name) return [];
+    return [
+      {
+        id: typeof obj.id === "string" && obj.id ? obj.id : `call_${index}`,
+        name,
+        arguments: parseToolArguments(fn.arguments ?? obj.arguments)
+      }
+    ];
+  });
+}
+function parseToolArguments(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return objectValue(parsed) ?? {};
+    } catch {
+      return {};
+    }
+  }
+  return objectValue(value) ?? {};
+}
+function workersAiUsage(value) {
+  const input = numberValue(value?.input_tokens) ?? numberValue(value?.prompt_tokens) ?? numberValue(value?.input) ?? 0;
+  const output = numberValue(value?.output_tokens) ?? numberValue(value?.completion_tokens) ?? numberValue(value?.output) ?? 0;
+  const cacheRead = numberValue(objectValue(value?.prompt_tokens_details)?.cached_tokens) ?? numberValue(value?.cache_read_tokens) ?? 0;
+  const cacheWrite = numberValue(objectValue(value?.prompt_tokens_details)?.cache_write_tokens) ?? numberValue(value?.cache_write_tokens) ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    totalTokens: numberValue(value?.total_tokens) ?? input + output + cacheRead + cacheWrite,
+    costTotal: 0
+  };
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function workersAiStopReason(reason) {
+  if (reason === "length") return "length";
+  if (reason === "tool_calls" || reason === "function_call") return "tool_use";
+  if (reason === "content_filter") return "error";
+  return "stop";
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function splitModel(ref) {
+  const slash = ref.indexOf("/");
+  if (slash === -1) throw new EngineError("invalid_model", `Model must be "<provider>/<model-id>", got "${ref}"`);
+  return { provider: ref.slice(0, slash), modelId: ref.slice(slash + 1) };
+}
+function resolveModel(provider, modelId, settings) {
+  const registered = resolveRegisteredModel(provider, modelId);
+  if (registered) return registered;
+  const model = getModel(provider, modelId);
+  if (model) return model;
+  const custom = settings?.models?.[modelId];
+  const api = custom?.api ?? settings?.api;
+  if (!custom || !api) {
+    throw new EngineError(
+      "unknown_model",
+      `Unknown model "${provider}/${modelId}". For custom providers, configure providers["${provider}"].models["${modelId}"] with an api.`
+    );
+  }
+  return {
+    id: modelId,
+    name: custom.name ?? modelId,
+    api,
+    provider,
+    baseUrl: custom.baseUrl ?? settings?.baseUrl ?? "",
+    reasoning: custom.reasoning ?? false,
+    thinkingLevelMap: custom.thinkingLevelMap,
+    input: custom.input ?? ["text"],
+    cost: {
+      input: custom.cost?.input ?? 0,
+      output: custom.cost?.output ?? 0,
+      cacheRead: custom.cost?.cacheRead ?? 0,
+      cacheWrite: custom.cost?.cacheWrite ?? 0
+    },
+    contextWindow: custom.contextWindow ?? 128e3,
+    maxTokens: custom.maxTokens ?? 16384,
+    headers: { ...settings?.headers ?? {}, ...custom.headers ?? {} },
+    compat: custom.compat
+  };
+}
+function applyProviderRuntimeSettings(model, settings, env) {
+  const accountId = settings?.accountId ?? stringEnv(env, "CLOUDFLARE_ACCOUNT_ID");
+  const baseUrl = expandProviderUrl(settings?.baseUrl ?? model.baseUrl, { CLOUDFLARE_ACCOUNT_ID: accountId });
+  const headers = settings?.headers ? { ...model.headers, ...settings.headers } : model.headers;
+  if (baseUrl === model.baseUrl && headers === model.headers) return model;
+  return { ...model, baseUrl, headers };
+}
+function expandProviderUrl(url, values) {
+  let out = url;
+  for (const [key, value] of Object.entries(values)) {
+    if (value) out = out.replaceAll(`{${key}}`, value);
+  }
+  return out;
+}
+function stringEnv(env, key) {
+  const value = env?.[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function toPiTool(tool) {
+  return { name: tool.name, description: tool.description, parameters: tool.parameters };
+}
+function toPiMessage(message, model) {
+  if (message.role === "user") {
+    return {
+      role: "user",
+      content: message.content.map(
+        (p) => p.type === "text" ? { type: "text", text: p.text } : { type: "image", data: p.data, mimeType: p.mimeType }
+      ),
+      timestamp: Date.now()
+    };
+  }
+  if (message.role === "tool_result") {
+    return {
+      role: "toolResult",
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      content: message.content.map(
+        (p) => p.type === "text" ? { type: "text", text: p.text } : { type: "image", data: p.data, mimeType: p.mimeType }
+      ),
+      isError: message.isError ?? false,
+      timestamp: Date.now()
+    };
+  }
+  const content = message.content.map((p) => {
+    if (p.type === "text") return { type: "text", text: p.text };
+    if (p.type === "thinking") return { type: "thinking", thinking: p.thinking };
+    return { type: "toolCall", id: p.id, name: p.name, arguments: p.arguments };
+  });
+  return {
+    role: "assistant",
+    content,
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: zeroPiUsage(),
+    stopReason: toPiStopReason(message.stopReason),
+    timestamp: Date.now()
+  };
+}
+function fromPiAssistant(assistant) {
+  return {
+    role: "assistant",
+    content: assistant.content.map((c) => {
+      if (c.type === "text") return { type: "text", text: c.text };
+      if (c.type === "thinking") return { type: "thinking", thinking: c.thinking };
+      return { type: "tool_call", id: c.id, name: c.name, arguments: c.arguments };
+    }),
+    usage: mapUsage(assistant.usage),
+    stopReason: fromPiStopReason(assistant.stopReason)
+  };
+}
+function textOf(message) {
+  return message.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+}
+function mapUsage(u) {
+  return {
+    inputTokens: u.input,
+    outputTokens: u.output,
+    cacheReadTokens: u.cacheRead,
+    cacheWriteTokens: u.cacheWrite,
+    totalTokens: u.totalTokens,
+    costTotal: u.cost.total
+  };
+}
+function addPiUsage(acc, u) {
+  return {
+    inputTokens: acc.inputTokens + u.input,
+    outputTokens: acc.outputTokens + u.output,
+    cacheReadTokens: acc.cacheReadTokens + u.cacheRead,
+    cacheWriteTokens: acc.cacheWriteTokens + u.cacheWrite,
+    totalTokens: acc.totalTokens + u.totalTokens,
+    costTotal: acc.costTotal + u.cost.total
+  };
+}
+function zeroPiUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+}
+function toPiStopReason(reason) {
+  return reason === "tool_use" ? "toolUse" : reason;
+}
+function fromPiStopReason(reason) {
+  return reason === "toolUse" ? "tool_use" : reason;
+}
+
+// src/events.ts
+var EventBus = class {
+  #subscribers = /* @__PURE__ */ new Set();
+  #index;
+  /**
+   * `startIndex` seeds event numbering. Recovery re-invokes a run with the same
+   * runId; seeding with the persisted event count keeps the per-run event log
+   * append-only instead of colliding with (or overwriting) attempt one.
+   */
+  constructor(startIndex = 0) {
+    this.#index = startIndex;
+  }
+  subscribe(fn) {
+    this.#subscribers.add(fn);
+    return () => this.#subscribers.delete(fn);
+  }
+  emit(event) {
+    const full = { ...event, index: this.#index++, timestamp: event.timestamp ?? Date.now() };
+    for (const fn of this.#subscribers) {
+      try {
+        fn(full);
+      } catch {
+      }
+    }
+  }
+};
+var globalSubscribers = /* @__PURE__ */ new Set();
+function observe(fn) {
+  globalSubscribers.add(fn);
+  return () => globalSubscribers.delete(fn);
+}
+function fanoutToGlobal(event) {
+  for (const fn of globalSubscribers) {
+    try {
+      fn(event);
+    } catch {
+    }
+  }
+}
+
+// src/call.ts
+function makeCall(run, parentSignal) {
+  const controller = new AbortController();
+  let detach;
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      controller.abort(parentSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(parentSignal.reason);
+      parentSignal.addEventListener("abort", onAbort, { once: true });
+      detach = () => parentSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  const promise = run(controller.signal);
+  promise.then(
+    () => detach?.(),
+    // Swallow here so an unawaited handle never becomes an unhandled rejection;
+    // callers that await still receive the rejection through then() below.
+    () => detach?.()
+  );
+  return {
+    signal: controller.signal,
+    abort: (reason) => controller.abort(reason),
+    then: (onfulfilled, onrejected) => promise.then(onfulfilled, onrejected)
+  };
+}
+
+// src/tools.ts
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+function defineTool(def) {
+  return def;
+}
+function rawTool(tool) {
+  return { ...tool, __atlasflowRawTool: true };
+}
+function isRawTool(tool) {
+  return typeof tool === "object" && tool !== null && tool.__atlasflowRawTool === true;
+}
+function resolveTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    parameters: toJsonSchema(def.parameters),
+    approval: normalizeToolApprovalPolicy(def.approval),
+    execute: async (args, signal) => {
+      const parsed = v.parse(def.parameters, args);
+      const result = await def.execute(parsed, signal);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  };
+}
+function resolveAnyTool(tool) {
+  if (isRawTool(tool)) {
+    return { name: tool.name, description: tool.description, parameters: tool.parameters, approval: tool.approval, execute: tool.execute };
+  }
+  return resolveTool(tool);
+}
+
+// src/session.ts
+import { toJsonSchema as toJsonSchema2 } from "@valibot/to-json-schema";
+import * as v2 from "valibot";
+var operationCounter = 0;
+var SESSION_JOURNAL_KEY = "atlasflow:journal";
+var keyLocks = /* @__PURE__ */ new Map();
+async function withKeyLock(key, fn) {
+  const prev = keyLocks.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.catch(() => {
+  });
+  keyLocks.set(key, tail);
+  void tail.then(() => {
+    if (keyLocks.get(key) === tail) keyLocks.delete(key);
+  });
+  return run;
+}
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) chars += JSON.stringify(m.content).length;
+  return Math.ceil(chars / 4);
+}
+var DEFAULT_COMPACTION = {
+  thresholdTokens: 12e4,
+  keepRecent: 10
+};
+var Session = class _Session {
+  name;
+  fs;
+  #ctx;
+  #key;
+  constructor(name, ctx) {
+    this.name = name;
+    this.#ctx = ctx;
+    this.#key = `${ctx.agentName}::${ctx.instanceId}::${name}`;
+    this.fs = ctx.env ? makeFs(ctx.env) : noFs();
+  }
+  prompt(text, options) {
+    return makeCall((signal) => this.#run(text, options ?? {}, "prompt", signal), options?.signal);
+  }
+  skill(ref, options) {
+    const skill = typeof ref === "string" ? this.#ctx.skills.get(ref) : ref;
+    if (!skill) throw new Error(`Unknown skill "${typeof ref === "string" ? ref : ref.name}"`);
+    return makeCall(async (signal) => {
+      if (!isWorkspaceSkill(skill)) return this.#run(skill.body, options ?? {}, "skill", signal);
+      if (!this.#ctx.env) throw new Error(`Workspace skill "${skill.name}" requires a sandbox environment.`);
+      const loaded = await loadWorkspaceSkill(this.#ctx.env, skill);
+      return this.#run(loaded.body, options ?? {}, "skill", signal);
+    }, options?.signal);
+  }
+  task(text, options) {
+    return makeCall((signal) => {
+      const sub = new _Session(`${this.name}/sub${++operationCounter}`, this.#ctx);
+      return sub.#run(text, options ?? {}, "task", signal);
+    }, options?.signal);
+  }
+  /** Branch this conversation: copy the current history into a new named session. */
+  async fork(name) {
+    const data = await this.#load();
+    const sub = new _Session(name, this.#ctx);
+    await this.#ctx.store.put(sub.#key, { ...structuredClone(data), name });
+    return sub;
+  }
+  shell(command, options) {
+    return makeCall(async (signal) => {
+      if (!this.#ctx.env) throw new Error("No sandbox configured for this agent (sandbox: false).");
+      const env = await createScopedSessionEnv(this.#ctx.env, mergeCommands(this.#ctx.commands, options?.commands));
+      return env.exec(command, { cwd: options?.cwd, timeoutMs: options?.timeoutMs, signal });
+    }, options?.signal);
+  }
+  async delete() {
+    await this.#ctx.store.delete(this.#key);
+  }
+  /** Manually compact this session's history, keeping the most recent messages. */
+  async compact(keepRecent = 4) {
+    const model = this.#ctx.model;
+    if (!model) return;
+    const data = await this.#load();
+    await this.#compact(data, model, keepRecent, void 0);
+    await this.#ctx.store.put(this.#key, data);
+  }
+  async #maybeCompact(data, model, signal) {
+    if (this.#ctx.compaction === false || !model) return;
+    const cfg = this.#ctx.compaction ?? {};
+    const overMessages = cfg.threshold != null && data.messages.length > cfg.threshold;
+    const overTokens = estimateTokens(data.messages) > (cfg.thresholdTokens ?? DEFAULT_COMPACTION.thresholdTokens);
+    if (!overMessages && !overTokens) return;
+    await this.#compact(data, cfg.model ?? model, cfg.keepRecent ?? DEFAULT_COMPACTION.keepRecent, signal);
+    await this.#ctx.store.put(this.#key, data);
+  }
+  /** Summarize all but the most recent `keepRecent` messages into one note. */
+  async #compact(data, model, keepRecent, signal) {
+    if (data.messages.length <= keepRecent) return;
+    const older = data.messages.slice(0, data.messages.length - keepRecent);
+    const recent = data.messages.slice(data.messages.length - keepRecent);
+    const transcript = older.map(renderMessage).join("\n");
+    const summary = await this.#ctx.engine.run(
+      {
+        model,
+        instructions: "Summarize the following conversation concisely, preserving key facts, decisions, and open threads. Output only the summary.",
+        messages: [{ role: "user", content: [{ type: "text", text: transcript }] }],
+        tools: [],
+        signal,
+        apiKey: this.#ctx.apiKey,
+        env: this.#ctx.envVars,
+        providers: this.#ctx.providers
+      },
+      { bus: this.#ctx.bus, runId: this.#ctx.runId, session: this.name }
+    );
+    const before = estimateTokens(older);
+    data.messages = [{ role: "user", content: [{ type: "text", text: `[Summary of earlier conversation]
+${summary.text}` }] }, ...recent];
+    data.updatedAt = Date.now();
+    const freedTokens = Math.max(0, before - Math.ceil(summary.text.length / 4));
+    this.#ctx.bus.emit({ type: "compaction", freedTokens, runId: this.#ctx.runId, session: this.name });
+  }
+  async #run(text, options, kind, signal) {
+    const ctx = this.#ctx;
+    const operationId = `op_${++operationCounter}`;
+    ctx.bus.emit({ type: "operation_start", operationId, kind, runId: ctx.runId, session: this.name });
+    try {
+      const result = kind === "task" ? await this.#runInner(text, options, kind, signal, operationId) : await withKeyLock(this.#key, () => this.#runInner(text, options, kind, signal, operationId));
+      ctx.bus.emit({ type: "operation_end", operationId, ok: true, runId: ctx.runId, session: this.name });
+      return result;
+    } catch (err) {
+      ctx.bus.emit({ type: "operation_end", operationId, ok: false, runId: ctx.runId, session: this.name });
+      throw err;
+    }
+  }
+  async #runInner(text, options, kind, signal, operationId) {
+    const ctx = this.#ctx;
+    const model = options.model ?? ctx.model;
+    if (!model) throw new Error("No model configured. Set `model` in the agent config or pass it per-call.");
+    const data = kind === "task" ? { name: this.name, messages: [], metadata: {}, createdAt: Date.now(), updatedAt: Date.now() } : await this.#load();
+    const replayEntry = kind === "task" ? void 0 : findReplayableJournalEntry(data, ctx.runId, kind, { includeApprovalParked: true });
+    if (kind !== "task" && !replayEntry) await this.#maybeCompact(data, model, signal);
+    const userParts = [{ type: "text", text }];
+    for (const img of options.images ?? []) userParts.push({ type: "image", data: img.data, mimeType: img.mimeType });
+    const userMessage = { role: "user", content: userParts };
+    const callCommands = mergeCommands(ctx.commands, options.commands);
+    if (callCommands.length && !ctx.env) throw new Error("Cannot use commands without a sandbox environment.");
+    const callEnv = ctx.env ? await createScopedSessionEnv(ctx.env, callCommands) : void 0;
+    const tools = [
+      ...ctx.tools,
+      ...callEnv && ctx.sandboxTools ? ctx.sandboxTools(callEnv) : [],
+      ...(options.tools ?? []).map(resolveTool)
+    ];
+    const instructions = this.#composeInstructions(options.result);
+    let journalOperationId = operationId;
+    if (kind !== "task" && replayEntry) {
+      journalOperationId = replayEntry.operationId;
+      markJournalReplay(data, replayEntry.operationId);
+      data.updatedAt = Date.now();
+      await ctx.store.put(this.#key, data);
+    } else if (kind !== "task") {
+      const inputStart = data.messages.length;
+      data.messages.push(userMessage);
+      beginJournalEntry(data, {
+        operationId,
+        kind,
+        status: "running",
+        runId: ctx.runId,
+        session: this.name,
+        startedAt: Date.now(),
+        inputStart,
+        inputCount: 1,
+        outputStart: data.messages.length,
+        outputCount: 0
+      });
+      data.updatedAt = Date.now();
+      await ctx.store.put(this.#key, data);
+    }
+    let result;
+    try {
+      result = await ctx.engine.run(
+        {
+          model,
+          instructions,
+          messages: kind === "task" ? [userMessage] : [...data.messages],
+          tools,
+          thinkingLevel: options.thinkingLevel ?? ctx.thinkingLevel,
+          toolChoice: options.toolChoice ?? ctx.toolChoice,
+          signal,
+          apiKey: ctx.apiKey,
+          env: ctx.envVars,
+          providers: ctx.providers,
+          sessionId: this.#key
+        },
+        { bus: ctx.bus, runId: ctx.runId, session: this.name }
+      );
+      if (kind !== "task") {
+        appendJournalOutput(data, journalOperationId, result.appended, result.usage);
+        data.updatedAt = Date.now();
+        await ctx.store.put(this.#key, data);
+      }
+      let parsed;
+      if (options.result) parsed = await this.#extractResult(options.result, result.text, instructions, model, signal);
+      if (kind !== "task") {
+        completeJournalEntry(data, journalOperationId);
+        data.updatedAt = Date.now();
+        await ctx.store.put(this.#key, data);
+      }
+      return { text: result.text, data: parsed, usage: result.usage };
+    } catch (err) {
+      if (kind !== "task") {
+        if (isToolApprovalRequiredError(err)) {
+          const partial = toolApprovalPartialTranscript(err);
+          if (partial) appendJournalOutput(data, journalOperationId, partial.appended, partial.usage);
+          parkJournalEntryForToolApproval(data, journalOperationId);
+        } else {
+          failJournalEntry(data, journalOperationId, err);
+        }
+        data.updatedAt = Date.now();
+        await ctx.store.put(this.#key, data);
+      }
+      throw err;
+    }
+  }
+  #composeInstructions(resultSchema) {
+    const base = this.#ctx.instructions;
+    if (!resultSchema) return base;
+    const schema = JSON.stringify(toJsonSchema2(resultSchema));
+    const directive = `When you have the final answer, respond with ONLY a single JSON object that conforms to this JSON Schema. No prose, no markdown fences:
+${schema}`;
+    return base ? `${base}
+
+${directive}` : directive;
+  }
+  async #extractResult(schema, text, instructions, model, signal) {
+    const first = tryParse(schema, text);
+    if (first.ok) return first.value;
+    const repair = await this.#ctx.engine.run(
+      {
+        model,
+        instructions,
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: `Return ONLY the JSON object. Your previous reply was not valid JSON for the schema.
+
+Previous reply:
+${text}` }]
+          }
+        ],
+        tools: [],
+        signal,
+        apiKey: this.#ctx.apiKey,
+        env: this.#ctx.envVars,
+        providers: this.#ctx.providers
+      },
+      { bus: this.#ctx.bus, runId: this.#ctx.runId, session: this.name }
+    );
+    const second = tryParse(schema, repair.text);
+    if (second.ok) return second.value;
+    throw new Error(`Model output did not match the result schema:
+${second.error}`);
+  }
+  async #load() {
+    const existing = await this.#ctx.store.get(this.#key);
+    if (existing) {
+      existing.metadata ??= {};
+      return existing;
+    }
+    return { name: this.name, messages: [], metadata: {}, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+function beginJournalEntry(data, entry) {
+  const journal = journalEntries(data);
+  journal.push(entry);
+}
+function findReplayableJournalEntry(data, runId, kind, options = {}) {
+  if (!runId) return void 0;
+  return journalEntries(data).filter(
+    (entry) => entry.runId === runId && entry.kind === kind && entry.status === "running" && (entry.outputCount === 0 || options.includeApprovalParked && entry.resumeReason === "tool_approval")
+  ).find((entry) => {
+    const inputValid = entry.inputCount > 0 && entry.inputStart >= 0 && entry.inputStart + entry.inputCount <= data.messages.length;
+    const outputValid = entry.outputStart >= 0 && entry.outputCount >= 0 && entry.outputStart + entry.outputCount <= data.messages.length;
+    return inputValid && outputValid;
+  });
+}
+function hasReplayableJournalEntry(data, runId, kind = "prompt") {
+  return findReplayableJournalEntry(data, runId, kind) !== void 0;
+}
+function appendJournalOutput(data, operationId, appended, usage) {
+  if (!appended.length) return;
+  const entry = journalEntries(data).find((candidate) => candidate.operationId === operationId);
+  const outputStart = entry && entry.outputCount > 0 ? entry.outputStart : data.messages.length;
+  const outputCount = (entry?.outputCount ?? 0) + appended.length;
+  const combinedUsage = entry?.usage ? addUsage(entry.usage, usage) : usage;
+  data.messages.push(...appended);
+  recordJournalOutput(data, operationId, { outputStart, outputCount, usage: combinedUsage });
+}
+function markJournalReplay(data, operationId) {
+  const now = Date.now();
+  const journal = journalEntries(data);
+  const entry = journal.find((candidate) => candidate.operationId === operationId);
+  if (!entry) return;
+  entry.replayedAt = now;
+  entry.replayCount = (entry.replayCount ?? 0) + 1;
+}
+function recordJournalOutput(data, operationId, patch) {
+  updateJournalEntry(data, operationId, {
+    outputStart: patch.outputStart,
+    outputCount: patch.outputCount,
+    usage: patch.usage
+  });
+}
+function parkJournalEntryForToolApproval(data, operationId) {
+  updateJournalEntry(data, operationId, { resumeReason: "tool_approval" });
+}
+function completeJournalEntry(data, operationId) {
+  updateJournalEntry(data, operationId, {
+    status: "completed",
+    completedAt: Date.now(),
+    error: void 0
+  });
+}
+function failJournalEntry(data, operationId, err) {
+  updateJournalEntry(data, operationId, {
+    status: "failed",
+    completedAt: Date.now(),
+    error: { message: err instanceof Error ? err.message : String(err) }
+  });
+}
+function reconcileSessionJournal(data, reconciliation) {
+  let changed = false;
+  for (const entry of journalEntries(data)) {
+    if (entry.runId !== reconciliation.runId || entry.status !== "running") continue;
+    entry.status = reconciliation.status;
+    entry.completedAt = reconciliation.completedAt;
+    entry.error = reconciliation.error;
+    changed = true;
+  }
+  if (changed) data.updatedAt = Math.max(data.updatedAt, reconciliation.completedAt);
+  return changed;
+}
+function updateJournalEntry(data, operationId, patch) {
+  const journal = journalEntries(data);
+  const index = journal.findIndex((entry) => entry.operationId === operationId);
+  if (index === -1) return;
+  journal[index] = { ...journal[index], ...patch };
+}
+function journalEntries(data) {
+  const metadata = data.metadata ??= {};
+  const existing = metadata[SESSION_JOURNAL_KEY];
+  if (Array.isArray(existing)) return existing;
+  const journal = [];
+  metadata[SESSION_JOURNAL_KEY] = journal;
+  return journal;
+}
+function tryParse(schema, text) {
+  const cleaned = stripFences(text);
+  let json;
+  try {
+    json = JSON.parse(cleaned);
+  } catch {
+    const extracted = extractJsonObject(cleaned);
+    if (extracted === null) return { ok: false, error: "no JSON object found in output" };
+    try {
+      json = JSON.parse(extracted);
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  const r = v2.safeParse(schema, json);
+  if (r.success) return { ok: true, value: r.output };
+  return { ok: false, error: r.issues.map((i) => i.message).join("; ") };
+}
+function stripFences(text) {
+  const trimmed = text.trim();
+  const fence = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
+  return fence?.[1] ? fence[1].trim() : trimmed;
+}
+function extractJsonObject(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end === -1 || end < start) return null;
+  return text.slice(start, end + 1);
+}
+function renderMessage(m) {
+  if (m.role === "user") return `User: ${m.content.map((p) => p.type === "text" ? p.text : "[image]").join("")}`;
+  if (m.role === "assistant")
+    return `Assistant: ${m.content.map((p) => p.type === "text" ? p.text : p.type === "tool_call" ? `[calls ${p.name}]` : "").join("")}`;
+  return `Tool(${m.toolName}): ${m.content.map((p) => p.type === "text" ? p.text : "").join("")}`;
+}
+function noFs() {
+  const fail = () => {
+    throw new Error("No sandbox configured for this agent (sandbox: false).");
+  };
+  return { readFile: fail, readFileBuffer: fail, writeFile: fail, stat: fail, readdir: fail, exists: async () => false, mkdir: fail, rm: fail };
+}
+
+// src/harness.ts
+var Harness = class {
+  name;
+  fs;
+  #ctx;
+  #sessions = /* @__PURE__ */ new Map();
+  constructor(name, ctx) {
+    this.name = name;
+    this.#ctx = ctx;
+    this.fs = ctx.env ? makeFs(ctx.env) : neverFs();
+  }
+  async session(name) {
+    const key = name ?? this.#ctx.instanceId;
+    let session = this.#sessions.get(key);
+    if (!session) {
+      session = new Session(key, this.#ctx);
+      this.#sessions.set(key, session);
+    }
+    return session;
+  }
+  shell(command, options) {
+    return makeCall(async (signal) => {
+      if (!this.#ctx.env) throw new Error("No sandbox configured for this agent (sandbox: false).");
+      const env = await createScopedSessionEnv(this.#ctx.env, mergeCommands(this.#ctx.commands, options?.commands));
+      return env.exec(command, { cwd: options?.cwd, timeoutMs: options?.timeoutMs, signal });
+    }, options?.signal);
+  }
+};
+function neverFs() {
+  const fail = () => {
+    throw new Error("No sandbox configured for this agent (sandbox: false).");
+  };
+  return { readFile: fail, readFileBuffer: fail, writeFile: fail, stat: fail, readdir: fail, exists: async () => false, mkdir: fail, rm: fail };
+}
+
+// src/runtime.ts
+var defaultEngine = new PiAgentEngine();
+var sharedPersistence = null;
+function getDefaultPersistence() {
+  if (!sharedPersistence) sharedPersistence = inMemoryAdapter();
+  return sharedPersistence;
+}
+var HEADLESS_DIRECTIVE = "You are running unattended. Work autonomously to complete the request \u2014 never ask the user questions or wait for confirmation.";
+var DEFAULT_RUN_LEASE_TTL_MS = 5 * 6e4;
+function genId(prefix) {
+  const rand = Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+  return `${prefix}_${Date.now().toString(36)}${rand}`;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function backoffMs(attempt) {
+  return Math.min(200 * 2 ** attempt, 5e3);
+}
+async function dispatchWorkflow(options) {
+  const runId = options.runId ?? genId("run");
+  const persistence = options.persistence ?? getDefaultPersistence();
+  const owner = options.runLeaseOwner ?? genId("lease");
+  const leaseTtlMs = options.runLeaseTtlMs ?? DEFAULT_RUN_LEASE_TTL_MS;
+  if (options.runLeaseOwner) {
+    const done2 = runDurably(options, runId, () => invokeAgent({ ...options, persistence, runId, runLeaseOwner: owner, runLeaseTtlMs: leaseTtlMs }).then(() => void 0)).then(
+      () => void 0,
+      () => void 0
+    );
+    return { runId, done: done2 };
+  }
+  const now = Date.now();
+  const existing = await persistence.runs.get(runId);
+  if (!existing) {
+    await persistence.runs.create({
+      runId,
+      agent: options.agentName,
+      instanceId: options.instanceId,
+      status: "queued",
+      startedAt: now,
+      message: options.message,
+      payload: options.payload,
+      images: options.images
+    });
+    await appendQueuedEvent(persistence, { runId, agent: options.agentName, instanceId: options.instanceId, timestamp: now });
+  } else if (existing.status !== "queued") {
+    throw new Error(`run "${runId}" is already ${existing.status}`);
+  }
+  const done = runDurably(options, runId, () => executeQueuedRun(options, persistence, runId, owner, leaseTtlMs)).then(
+    () => void 0,
+    () => void 0
+    // terminal failure is already recorded on the run record
+  );
+  return { runId, done };
+}
+function runDurably(options, runId, run) {
+  if (!options.durability) return run();
+  return Promise.resolve(
+    options.durability(
+      {
+        runId,
+        agentName: options.agentName,
+        instanceId: options.instanceId,
+        resume: options.runResume === true
+      },
+      run
+    )
+  );
+}
+async function executeQueuedRun(options, persistence, runId, owner, leaseTtlMs) {
+  const claimed = await persistence.runs.claimQueued(runId, owner, Date.now(), leaseTtlMs);
+  if (!claimed) return;
+  await invokeAgent({ ...options, persistence, runId, runLeaseOwner: owner, runLeaseTtlMs: leaseTtlMs });
+}
+async function appendQueuedEvent(persistence, event) {
+  const index = await persistence.runs.eventCount?.(event.runId) ?? (await persistence.runs.events(event.runId)).length;
+  await persistence.runs.appendEvent(event.runId, {
+    type: "run_queued",
+    agent: event.agent,
+    instanceId: event.instanceId,
+    runId: event.runId,
+    index,
+    timestamp: event.timestamp
+  });
+}
+async function recoverRuns(agents, opts) {
+  const persistence = opts?.persistence ?? getDefaultPersistence();
+  const leaseTtlMs = opts?.leaseTtlMs ?? DEFAULT_RUN_LEASE_TTL_MS;
+  const agentRecovery = opts?.agentRecovery ?? "auto";
+  const scopedRunIds = opts?.runIds ? new Set(opts.runIds) : void 0;
+  if (opts?.forceLeaseExpiration && !scopedRunIds) {
+    throw new Error("recoverRuns forceLeaseExpiration requires runIds");
+  }
+  const recovered = [];
+  const queued = scopedRunIds ? await runsById(persistence, scopedRunIds, "queued") : await persistence.runs.list({ status: "queued" });
+  for (const run of queued) {
+    if (run.kind === "workflow") continue;
+    const owner = genId("recovery");
+    const claimed = await persistence.runs.claimQueued(run.runId, owner, Date.now(), leaseTtlMs);
+    if (!claimed) continue;
+    const agent = agents[run.agent];
+    if (!agent) {
+      await interruptRecoveredRun(persistence, run, owner, "unknown_agent", `agent "${run.agent}" is no longer registered`);
+      recovered.push(run.runId);
+      continue;
+    }
+    await dispatchWorkflow({
+      agent,
+      agentName: run.agent,
+      instanceId: run.instanceId,
+      message: run.message,
+      payload: run.payload,
+      images: run.images,
+      persistence,
+      engine: opts?.engine,
+      env: opts?.env,
+      runId: run.runId,
+      runLeaseOwner: owner,
+      runLeaseTtlMs: leaseTtlMs,
+      durability: opts?.durability
+    });
+    recovered.push(run.runId);
+  }
+  const running = scopedRunIds ? await runsById(persistence, scopedRunIds, "running") : await persistence.runs.list({ status: "running" });
+  for (const run of running) {
+    if (run.kind === "workflow") continue;
+    const owner = genId("recovery");
+    if (opts?.forceLeaseExpiration) {
+      await persistence.runs.update(run.runId, { leaseExpiresAt: 0 });
+    }
+    const claimed = await persistence.runs.claimLease(run.runId, owner, Date.now(), leaseTtlMs);
+    if (!claimed) continue;
+    const agent = agents[run.agent];
+    if (!agent) {
+      await interruptRecoveredRun(persistence, run, owner, "unknown_agent", `agent "${run.agent}" is no longer registered`);
+      continue;
+    }
+    const shouldReplay = agentRecovery === "replay" || agentRecovery === "auto" && await canSafelyReplayAgentRun(persistence, run);
+    if (!shouldReplay) {
+      await interruptRecoveredRun(
+        persistence,
+        run,
+        owner,
+        "recovery_interrupted",
+        "run was still marked running after its execution lease expired; it was not replayed to avoid duplicate side effects"
+      );
+      recovered.push(run.runId);
+      continue;
+    }
+    await dispatchWorkflow({
+      agent,
+      agentName: run.agent,
+      instanceId: run.instanceId,
+      message: run.message,
+      payload: run.payload,
+      images: run.images,
+      persistence,
+      engine: opts?.engine,
+      env: opts?.env,
+      runId: run.runId,
+      runLeaseOwner: owner,
+      runLeaseTtlMs: leaseTtlMs,
+      runResume: true,
+      durability: opts?.durability
+    });
+    recovered.push(run.runId);
+  }
+  return recovered;
+}
+async function runsById(persistence, runIds, status) {
+  const runs = [];
+  for (const runId of runIds) {
+    const run = await persistence.runs.get(runId);
+    if (run?.status === status) runs.push(run);
+  }
+  return runs.sort((a, b) => b.startedAt - a.startedAt);
+}
+var SAFE_AUTO_REPLAY_EVENT_TYPES = /* @__PURE__ */ new Set(["run_queued", "run_start", "run_resume", "agent_start", "operation_start"]);
+async function canSafelyReplayAgentRun(persistence, run) {
+  const sessionKey = `${run.agent}::${run.instanceId}::${run.instanceId}`;
+  const session = await persistence.sessions.get(sessionKey);
+  if (!session || !hasReplayableJournalEntry(session, run.runId, "prompt")) return false;
+  const events = await persistence.runs.events(run.runId);
+  return events.every((event) => SAFE_AUTO_REPLAY_EVENT_TYPES.has(event.type));
+}
+async function interruptRecoveredRun(persistence, run, leaseOwner, code, message) {
+  const endedAt = Date.now();
+  await persistence.runs.update(run.runId, { status: "interrupted", error: { code, message }, endedAt });
+  await reconcileRecoveredRunJournal(persistence, run, { code, message, endedAt });
+  const startIndex = await persistence.runs.eventCount?.(run.runId) ?? (await persistence.runs.events(run.runId)).length;
+  await persistence.runs.appendEvent(run.runId, {
+    type: "run_error",
+    code,
+    message,
+    runId: run.runId,
+    index: startIndex,
+    timestamp: endedAt
+  });
+  await persistence.runs.appendEvent(run.runId, {
+    type: "run_end",
+    ok: false,
+    runId: run.runId,
+    index: startIndex + 1,
+    timestamp: endedAt
+  });
+  await persistence.runs.releaseLease(run.runId, leaseOwner).catch(() => {
+  });
+}
+async function reconcileRecoveredRunJournal(persistence, run, error) {
+  const sessionKey = `${run.agent}::${run.instanceId}::${run.instanceId}`;
+  const session = await persistence.sessions.get(sessionKey);
+  if (!session) return;
+  const changed = reconcileSessionJournal(session, {
+    runId: run.runId,
+    status: "interrupted",
+    completedAt: error.endedAt,
+    error: { code: error.code, message: error.message }
+  });
+  if (changed) await persistence.sessions.put(sessionKey, session);
+}
+function skillTool(skill, model, tools, sub) {
+  const allowed = skill.allowedTools ? tools.filter((t) => skill.allowedTools.includes(t.name)) : tools;
+  return {
+    name: `skill_${skill.name}`,
+    description: `Run the "${skill.name}" skill. ${skill.description}`,
+    parameters: {
+      type: "object",
+      properties: { input: { type: "string", description: "Input or context to give the skill." } },
+      required: ["input"]
+    },
+    execute: async (args, signal) => {
+      if (!model) throw new Error(`Skill "${skill.name}" requires a model to be configured.`);
+      const res = await sub.engine.run(
+        {
+          model,
+          instructions: skillInstructions(skill),
+          messages: [{ role: "user", content: [{ type: "text", text: String(args.input ?? "") }] }],
+          tools: allowed,
+          signal,
+          apiKey: sub.apiKey,
+          env: sub.env,
+          providers: sub.providers
+        },
+        { bus: sub.bus, runId: sub.runId, session: `skill:${skill.name}` }
+      );
+      return res.text;
+    }
+  };
+}
+function skillInstructions(skill) {
+  const files = Object.keys(skill.files ?? {});
+  if (!files.length) return skill.body;
+  const root = `.atlasflow/packaged-skills/${skill.name}`;
+  return [
+    skill.body,
+    "",
+    "Packaged skill resources are mounted in the sandbox. Read them when relevant:",
+    ...files.map((file) => `- ${root}/${file}`)
+  ].join("\n");
+}
+function activateSkillTool(env, workspaceSkills) {
+  const byName = new Map(workspaceSkills.map((skill) => [skill.name, skill]));
+  return {
+    name: "activate_skill",
+    description: "Load the full instructions for a workspace skill before using it.",
+    parameters: {
+      type: "object",
+      properties: { name: { type: "string", description: "Workspace skill name from the Available Skills list." } },
+      required: ["name"]
+    },
+    execute: async (args) => {
+      const name = String(args.name ?? "");
+      const skill = byName.get(name);
+      if (!skill) throw new Error(`Unknown workspace skill "${name}".`);
+      const loaded = await loadWorkspaceSkill(env, skill);
+      return [`# Skill: ${loaded.name}`, "", loaded.description, "", loaded.body].join("\n");
+    }
+  };
+}
+function loadSkillInstructions(skills) {
+  const items = [...skills];
+  if (!items.length) return void 0;
+  return [
+    "## Available Skills",
+    "",
+    "The following skills provide specialized instructions. When a task matches a skill description, call the `load_skill` tool with that skill name before proceeding so its full instructions are loaded.",
+    "",
+    ...items.map((skill) => `- **${skill.name}**${skill.description ? ` - ${skill.description}` : ""}`)
+  ].join("\n");
+}
+function loadSkillTool(env, skills) {
+  return {
+    name: "load_skill",
+    description: "Load the full instructions for an available skill before using it.",
+    parameters: {
+      type: "object",
+      properties: { name: { type: "string", description: "Skill name from the Available Skills list." } },
+      required: ["name"]
+    },
+    execute: async (args) => {
+      const name = String(args.name ?? "");
+      const skill = skills.get(name);
+      if (!skill) throw new Error(`Unknown skill "${name}".`);
+      const loaded = isWorkspaceSkill(skill) ? await loadWorkspaceSkillForTool(env, skill) : skill;
+      return [`# Skill: ${loaded.name}`, "", loaded.description, "", skillInstructions(loaded)].join("\n");
+    }
+  };
+}
+async function loadWorkspaceSkillForTool(env, skill) {
+  if (!env) throw new Error(`Workspace skill "${skill.name}" requires a sandbox environment.`);
+  return loadWorkspaceSkill(env, skill);
+}
+function taskTool(defaultModel, defaultInstructions, tools, subagents, sub) {
+  const profiles = new Map(subagents.map((p) => [p.name, p]));
+  const agentNames = [...profiles.keys()];
+  return {
+    name: "task",
+    description: `Delegate a self-contained task to a sub-agent running in a fresh context. ` + (agentNames.length ? `Available agents: ${agentNames.join(", ")} (omit "agent" for a general-purpose one). ` : "") + "Returns the sub-agent's final answer.",
+    parameters: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Complete, self-contained instructions for the sub-agent." },
+        agent: { type: "string", description: agentNames.length ? `Subagent profile: one of ${agentNames.join(", ")}.` : "Unused." }
+      },
+      required: ["prompt"]
+    },
+    execute: async (args, signal) => {
+      const profile = args.agent != null ? profiles.get(String(args.agent)) : void 0;
+      if (args.agent != null && !profile) throw new Error(`Unknown subagent "${args.agent}". Available: ${agentNames.join(", ") || "(none)"}`);
+      const model = profile?.model ?? defaultModel;
+      if (!model) throw new Error("task requires a model to be configured.");
+      const taskId = genId("task");
+      sub.bus.emit({ type: "task_start", taskId, agent: profile?.name ?? "task", runId: sub.runId });
+      try {
+        const res = await sub.engine.run(
+          {
+            model,
+            instructions: profile?.instructions ?? defaultInstructions,
+            messages: [{ role: "user", content: [{ type: "text", text: String(args.prompt) }] }],
+            tools: tools.filter((t) => t.name !== "task"),
+            signal,
+            apiKey: sub.apiKey,
+            env: sub.env,
+            providers: sub.providers
+          },
+          { bus: sub.bus, runId: sub.runId, session: `task:${taskId}` }
+        );
+        sub.bus.emit({ type: "task_end", taskId, ok: true, runId: sub.runId });
+        return res.text;
+      } catch (err) {
+        sub.bus.emit({ type: "task_end", taskId, ok: false, runId: sub.runId });
+        throw err;
+      }
+    }
+  };
+}
+async function mountContextPacks(packs, sandboxEnv, bus, runId, options = {}) {
+  const notes = [];
+  const injectContent = options.injectContent !== false;
+  for (const pack of packs) {
+    const wantsSandbox = pack.mount === "sandbox";
+    if (wantsSandbox && sandboxEnv) {
+      const files = [];
+      for (const item of pack.items) {
+        const path = `packs/${pack.name}/${item.name}`;
+        const dir = `packs/${pack.name}`;
+        await sandboxEnv.mkdir(dir, { recursive: true }).catch(() => {
+        });
+        await sandboxEnv.writeFile(path, item.content);
+        files.push(path);
+      }
+      notes.push(
+        `## Context pack: ${pack.name}${pack.version ? ` (v${pack.version})` : ""}
+${pack.description ?? ""}
+Mounted in your workspace \u2014 read these files when relevant:
+${files.map((f) => `- ${f}`).join("\n")}`
+      );
+      continue;
+    }
+    if (wantsSandbox && !sandboxEnv) {
+      bus.emit({
+        type: "log",
+        level: "warn",
+        message: injectContent ? `context pack "${pack.name}" wants a sandbox mount but no sandbox is configured; injecting into context instead` : `context pack "${pack.name}" wants a sandbox mount but no sandbox is configured; keeping it available through load_context`,
+        runId
+      });
+    }
+    if (!injectContent) continue;
+    const body = pack.items.map((i) => `### ${i.name}
+${i.content}`).join("\n\n");
+    notes.push(`## Context pack: ${pack.name}${pack.version ? ` (v${pack.version})` : ""}
+${pack.description ?? ""}
+${body}`);
+  }
+  return notes;
+}
+function loadContextInstructions(packs) {
+  if (!packs.length) return void 0;
+  return [
+    "## Available Context",
+    "",
+    "The following context packs are available. When a task needs one of them, call the `load_context` tool with the pack name before relying on its details.",
+    "",
+    ...packs.map((pack) => {
+      const items = pack.items.map((item) => item.name).join(", ");
+      return `- **${pack.name}**${pack.description ? ` - ${pack.description}` : ""}${items ? ` (items: ${items})` : ""}`;
+    })
+  ].join("\n");
+}
+function loadContextTool(packs) {
+  return {
+    name: "load_context",
+    description: "Load the full contents of an available context pack before using its details.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Context pack name from the Available Context list." },
+        item: { type: "string", description: "Optional item name within the context pack." }
+      },
+      required: ["name"]
+    },
+    execute: async (args) => {
+      const name = String(args.name ?? "");
+      const pack = packs.get(name);
+      if (!pack) throw new Error(`Unknown context pack "${name}".`);
+      const itemName = typeof args.item === "string" && args.item.trim() ? args.item : void 0;
+      const items = itemName ? pack.items.filter((item) => item.name === itemName) : pack.items;
+      if (itemName && !items.length) throw new Error(`Unknown item "${itemName}" in context pack "${name}".`);
+      const body = items.map((item) => `### ${item.name}
+${item.content}`).join("\n\n");
+      return [`# Context pack: ${pack.name}${pack.version ? ` (v${pack.version})` : ""}`, "", pack.description ?? "", "", body].join("\n").trim();
+    }
+  };
+}
+async function mountPackagedSkillFiles(skills, sandboxEnv) {
+  if (!sandboxEnv) return [];
+  const notes = [];
+  for (const skill of skills) {
+    const files = Object.entries(skill.files ?? {});
+    if (!files.length) continue;
+    const root = `.atlasflow/packaged-skills/${skill.name}`;
+    const mounted = [];
+    for (const [relativePath, file] of files) {
+      const target = `${root}/${relativePath}`;
+      await sandboxEnv.writeFile(target, decodeBase64(file.content));
+      mounted.push(target);
+    }
+    notes.push(`## Packaged skill resources: ${skill.name}
+Mounted in your workspace \u2014 read these files when relevant:
+${mounted.map((file) => `- ${file}`).join("\n")}`);
+  }
+  return notes;
+}
+function decodeBase64(content) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(content, "base64"));
+  const binary = atob(content);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+async function invokeAgent(options) {
+  const env = options.env ?? process.env;
+  const engine = options.engine ?? defaultEngine;
+  const persistence = options.persistence ?? getDefaultPersistence();
+  const isRedispatch = options.runId != null;
+  const runId = options.runId ?? genId("run");
+  const leaseOwner = options.runLeaseOwner ?? genId("lease");
+  const leaseTtlMs = options.runLeaseTtlMs ?? DEFAULT_RUN_LEASE_TTL_MS;
+  let startIndex = 0;
+  if (isRedispatch) {
+    startIndex = await persistence.runs.eventCount?.(runId) ?? (await persistence.runs.events(runId)).length;
+  }
+  const bus = new EventBus(startIndex);
+  bus.subscribe((e) => {
+    fanoutToGlobal(e);
+    options.onEvent?.(e);
+    void persistence.runs.appendEvent(runId, e).catch(() => {
+    });
+  });
+  const record2 = {
+    runId,
+    agent: options.agentName,
+    instanceId: options.instanceId,
+    status: "running",
+    startedAt: Date.now(),
+    message: options.message,
+    payload: options.payload,
+    images: options.images,
+    leaseOwner,
+    leaseAcquiredAt: Date.now(),
+    leaseExpiresAt: Date.now() + leaseTtlMs
+  };
+  if (!await persistence.runs.get(runId)) await persistence.runs.create(record2);
+  else if (!options.runLeaseOwner && !await persistence.runs.claimLease(runId, leaseOwner, Date.now(), leaseTtlMs)) {
+    throw new Error(`run "${runId}" is already running under another live lease`);
+  }
+  bus.emit({ type: options.runResume ? "run_resume" : "run_start", agent: options.agentName, instanceId: options.instanceId, runId });
+  bus.emit({ type: "agent_start", agent: options.agentName, runId });
+  let sandboxEnv;
+  let configCleanup;
+  const leaseHeartbeat = setInterval(() => {
+    void persistence.runs.heartbeatLease(runId, leaseOwner, Date.now(), leaseTtlMs).catch(() => {
+    });
+  }, Math.max(1e3, Math.floor(leaseTtlMs / 3)));
+  leaseHeartbeat.unref?.();
+  try {
+    const rawConfig = await options.agent.initialize({ id: options.instanceId, env, payload: options.payload });
+    const config = applyProfile(rawConfig);
+    configCleanup = config.cleanup;
+    const model = config.model === false ? void 0 : config.model;
+    const guard = makeRuleGuard(config.rules ?? [], config.hooks, bus, runId);
+    const wrapRuntimeTool = (tool) => guard.wrapTool(wrapToolApproval(tool, { persistence, runId, bus }));
+    const tools = (config.tools ?? []).map(resolveAnyTool).map(wrapRuntimeTool);
+    const authorToolNames = new Set(tools.map((t) => t.name));
+    const declaredSkills = config.skills ?? [];
+    const lazySkillLoading = config.skillLoading === "load";
+    const skills = new Map(declaredSkills.map((s) => [s.name, s]));
+    const contextPacks = config.contextPacks ?? [];
+    const lazyContextLoading = config.contextLoading === "lazy";
+    const contextPackMap = new Map(contextPacks.map((pack) => [pack.name, pack]));
+    const sub = { engine, bus, runId, apiKey: options.apiKey, env, providers: config.providers };
+    let sandboxTools;
+    const sandboxFactory = config.sandbox === false ? void 0 : config.sandbox ?? virtualSandbox();
+    if (sandboxFactory) {
+      sandboxEnv = await sandboxFactory.createSessionEnv({ id: options.instanceId, env });
+      if (config.cwd) sandboxEnv = createCwdSessionEnv(sandboxEnv, config.cwd);
+      if (config.builtinTools !== false) {
+        const include = Array.isArray(config.builtinTools) ? config.builtinTools : void 0;
+        sandboxTools = (toolEnv) => builtinTools(toolEnv, { include }).filter((tool) => !authorToolNames.has(tool.name)).map(wrapRuntimeTool);
+      }
+    }
+    const packNotes = await mountContextPacks(contextPacks, sandboxEnv, bus, runId, { injectContent: !lazyContextLoading });
+    const skillFileNotes = await mountPackagedSkillFiles(declaredSkills, sandboxEnv);
+    let discoveredInstructions;
+    if (sandboxEnv) {
+      const discovered = await discoverSessionContext(sandboxEnv, declaredSkills);
+      discoveredInstructions = discovered.instructions;
+      for (const skill of discovered.workspaceSkills) skills.set(skill.name, skill);
+      if (discovered.workspaceSkills.length && !tools.some((t) => t.name === "activate_skill")) {
+        tools.push(wrapRuntimeTool(activateSkillTool(sandboxEnv, discovered.workspaceSkills)));
+      }
+    }
+    const lazySkillInstructions = lazySkillLoading ? loadSkillInstructions(skills.values()) : void 0;
+    const lazyContextInstructions = lazyContextLoading ? loadContextInstructions(contextPacks) : void 0;
+    const instructions = [options.baseInstructions, config.instructions, discoveredInstructions, lazySkillInstructions, lazyContextInstructions, ...packNotes, ...skillFileNotes, config.headless ? HEADLESS_DIRECTIVE : void 0].filter(Boolean).join("\n\n") || void 0;
+    const agentCommandEnv = sandboxEnv ? await createScopedSessionEnv(sandboxEnv, config.commands ?? []) : void 0;
+    const subcallTools = agentCommandEnv && sandboxTools ? [...tools, ...sandboxTools(agentCommandEnv)] : tools.slice();
+    if (lazySkillLoading && skills.size && !tools.some((t) => t.name === "load_skill")) {
+      tools.push(wrapRuntimeTool(loadSkillTool(sandboxEnv, skills)));
+    }
+    if (lazyContextLoading && contextPackMap.size && !tools.some((t) => t.name === "load_context")) {
+      tools.push(wrapRuntimeTool(loadContextTool(contextPackMap)));
+    }
+    if (!lazySkillLoading) {
+      for (const skill of skills.values()) {
+        if (isWorkspaceSkill(skill)) continue;
+        tools.push(wrapRuntimeTool(skillTool(skill, model, subcallTools, sub)));
+      }
+    }
+    const personas = [...options.sharedPersonas ?? options.sharedSubagents ?? [], ...config.personas ?? config.subagents ?? []];
+    const wantsTask = config.builtinTools === false ? false : !Array.isArray(config.builtinTools) || config.builtinTools.includes("task");
+    if (model && wantsTask && !tools.some((t) => t.name === "task")) {
+      const taskTools = agentCommandEnv && sandboxTools ? [...tools, ...sandboxTools(agentCommandEnv)] : tools.slice();
+      tools.push(wrapRuntimeTool(taskTool(model, instructions, taskTools, personas, sub)));
+    }
+    const ctx = {
+      engine,
+      model,
+      instructions,
+      tools,
+      skills,
+      thinkingLevel: config.thinkingLevel,
+      toolChoice: config.toolChoice,
+      env: sandboxEnv,
+      commands: config.commands,
+      sandboxTools,
+      store: persistence.sessions,
+      bus,
+      runId,
+      agentName: options.agentName,
+      instanceId: options.instanceId,
+      apiKey: options.apiKey,
+      envVars: env,
+      providers: config.providers,
+      compaction: config.compaction
+    };
+    const harness = new Harness(config.name ?? options.agentName, ctx);
+    const session = await harness.session();
+    const input = options.message ?? (options.payload != null ? JSON.stringify(options.payload) : "");
+    const retry = config.durability?.retry ?? 0;
+    const timeoutMs = config.durability?.timeoutMs;
+    let response;
+    let lastError;
+    await guard.checkPrompt(input);
+    for (let attempt = 0; attempt <= retry; attempt++) {
+      if (options.signal?.aborted) throw options.signal.reason ?? new Error("invocation aborted");
+      try {
+        const signals = [];
+        if (timeoutMs) signals.push(AbortSignal.timeout(timeoutMs));
+        if (options.signal) signals.push(options.signal);
+        const signal = signals.length ? AbortSignal.any(signals) : void 0;
+        response = config.result ? await session.prompt(input, { result: config.result, signal, images: options.images }) : await session.prompt(input, { signal, images: options.images });
+        lastError = void 0;
+        break;
+      } catch (err) {
+        lastError = err;
+        if (isToolApprovalRequiredError(err)) break;
+        if (options.signal?.aborted) break;
+        if (attempt < retry) {
+          const message = err instanceof Error ? err.message : String(err);
+          bus.emit({ type: "log", level: "warn", message: `attempt ${attempt + 1} failed: ${message}; retrying`, runId });
+          await sleep(backoffMs(attempt));
+        }
+      }
+    }
+    if (!response) throw lastError ?? new Error("agent produced no response");
+    await persistence.runs.update(runId, { status: "success", result: response.text, endedAt: Date.now() });
+    bus.emit({ type: "agent_end", runId });
+    bus.emit({ type: "run_end", ok: true, runId });
+    return { runId, text: response.text, data: response.data, usage: response.usage };
+  } catch (err) {
+    if (isToolApprovalRequiredError(err)) {
+      bus.emit({ type: "agent_end", runId });
+      throw err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err.code ?? "agent_error";
+    await persistence.runs.update(runId, { status: "failed", error: { code, message }, endedAt: Date.now() });
+    bus.emit({ type: "run_error", code, message, runId });
+    bus.emit({ type: "agent_end", runId });
+    bus.emit({ type: "run_end", ok: false, runId });
+    throw err;
+  } finally {
+    clearInterval(leaseHeartbeat);
+    await persistence.runs.releaseLease(runId, leaseOwner).catch(() => {
+    });
+    await sandboxEnv?.dispose?.().catch(() => {
+    });
+    if (configCleanup) await Promise.resolve(configCleanup()).catch(() => {
+    });
+  }
+}
+
+// src/workflow.ts
+import * as v3 from "valibot";
+var PromptStepSchema = v3.object({
+  id: v3.pipe(v3.string(), v3.minLength(1)),
+  kind: v3.literal("prompt"),
+  /** May reference prior steps: {{steps.<id>.text}}. */
+  prompt: v3.string(),
+  /** Role slot or persona name executing this step (default: workflow default persona). */
+  persona: v3.optional(v3.string()),
+  model: v3.optional(v3.string())
+});
+var SkillStepSchema = v3.object({
+  id: v3.pipe(v3.string(), v3.minLength(1)),
+  kind: v3.literal("skill"),
+  /** Name of a skill in the executing persona's loadout. */
+  skill: v3.string(),
+  /** Input text; may reference prior steps: {{steps.<id>.text}}. */
+  input: v3.optional(v3.string()),
+  persona: v3.optional(v3.string())
+});
+var GateStepSchema = v3.object({
+  id: v3.pipe(v3.string(), v3.minLength(1)),
+  kind: v3.literal("gate"),
+  title: v3.string(),
+  description: v3.optional(v3.string())
+});
+var WorkflowStepSchema = v3.variant("kind", [PromptStepSchema, SkillStepSchema, GateStepSchema]);
+var WorkflowDefSchema = v3.object({
+  name: v3.pipe(v3.string(), v3.minLength(1)),
+  description: v3.optional(v3.string()),
+  steps: v3.pipe(v3.array(WorkflowStepSchema), v3.minLength(1)),
+  /** Role slot → default persona name; rebindable at deploy. */
+  roleSlots: v3.optional(v3.record(v3.string(), v3.string()))
+});
+function parseWorkflowDef(value) {
+  const r = v3.safeParse(WorkflowDefSchema, value);
+  if (!r.success) {
+    throw new Error(`Invalid workflow definition: ${r.issues.map((i) => `${i.path?.map((p) => p.key).join(".") ?? ""} ${i.message}`).join("; ")}`);
+  }
+  return r.output;
+}
+function interpolate(template, state) {
+  return template.replace(/\{\{\s*steps\.([\w-]+)\.text\s*\}\}/g, (_m, id) => state.results[id]?.text ?? "");
+}
+function resolvePersona(step, def, ctx) {
+  const ref = step.persona ?? ctx.defaultPersona;
+  if (!ref) return void 0;
+  return ctx.bindings?.[ref] ?? def.roleSlots?.[ref] ?? ref;
+}
+async function startWorkflow(def, ctx = {}, opts) {
+  parseWorkflowDef(def);
+  const persistence = ctx.persistence ?? getDefaultPersistence();
+  const runId = opts?.runId ?? genId("run");
+  if (!await persistence.runs.get(runId)) {
+    const seed = opts?.payload != null ? { payload: { text: typeof opts.payload === "string" ? opts.payload : JSON.stringify(opts.payload) } } : {};
+    await persistence.runs.create({
+      runId,
+      agent: def.name,
+      instanceId: runId,
+      status: "running",
+      startedAt: Date.now(),
+      payload: opts?.payload,
+      kind: "workflow",
+      state: { cursor: 0, results: seed, gates: {} }
+    });
+  }
+  return advanceWorkflow(def, ctx, runId);
+}
+async function advanceWorkflow(def, ctx, runId) {
+  const persistence = ctx.persistence ?? getDefaultPersistence();
+  const record2 = await persistence.runs.get(runId);
+  if (!record2) throw new Error(`No workflow run "${runId}"`);
+  const state = record2.state ?? { cursor: 0, results: {}, gates: {} };
+  let lastText = "";
+  for (let i = state.cursor; i < def.steps.length; i++) {
+    const step = def.steps[i];
+    if (step.kind === "gate") {
+      const decision = state.gates[step.id];
+      if (!decision) {
+        state.cursor = i;
+        await persistence.runs.update(runId, { status: "waiting_approval", state });
+        return { runId, status: "waiting_approval", gate: { id: step.id, title: step.title } };
+      }
+      if (!decision.approved) {
+        await persistence.runs.update(runId, { status: "failed", error: { code: "gate_rejected", message: `Gate "${step.title}" rejected${decision.note ? `: ${decision.note}` : ""}` }, endedAt: Date.now(), state });
+        return { runId, status: "failed" };
+      }
+      state.cursor = i + 1;
+      await persistence.runs.update(runId, { status: "running", state });
+      continue;
+    }
+    try {
+      lastText = await executeStep(step, def, ctx, state, runId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await persistence.runs.update(runId, { status: "failed", error: { code: "step_failed", message: `step "${step.id}": ${message}` }, endedAt: Date.now(), state });
+      return { runId, status: "failed" };
+    }
+    state.results[step.id] = { text: lastText };
+    state.cursor = i + 1;
+    await persistence.runs.update(runId, { state });
+  }
+  await persistence.runs.update(runId, { status: "success", result: lastText, endedAt: Date.now(), state });
+  return { runId, status: "success", text: lastText };
+}
+async function executeStep(step, def, ctx, state, parentRunId) {
+  const personaName = resolvePersona(step, def, ctx);
+  const registered = personaName ? ctx.agents?.[personaName] : void 0;
+  const profile = personaName ? ctx.profiles?.find((p) => p.name === personaName) : void 0;
+  if (personaName && !registered && !profile) {
+    throw new Error(`Unknown persona "${personaName}" (role slots: ${Object.keys(def.roleSlots ?? {}).join(", ") || "none"})`);
+  }
+  let message;
+  let agent = registered;
+  if (step.kind === "prompt") {
+    message = interpolate(step.prompt, state);
+  } else {
+    const skill = ctx.skills?.find((s) => s.name === step.skill);
+    if (!skill) throw new Error(`Unknown skill "${step.skill}"`);
+    message = interpolate(step.input ?? "", state);
+    if (registered) {
+      const res3 = await invokeAgent({
+        agent: registered,
+        agentName: `${def.name}/${step.id}`,
+        instanceId: `${parentRunId}/${step.id}`,
+        message: `${skill.body}
+
+--- INPUT ---
+${message}`,
+        persistence: ctx.persistence,
+        engine: ctx.engine,
+        env: ctx.env,
+        onEvent: ctx.onEvent,
+        baseInstructions: ctx.baseInstructions
+      });
+      return res3.text;
+    }
+    const model = profile?.model ?? ctx.defaultModel;
+    if (!model) throw new Error(`Skill step "${step.id}" needs a model (set workflow defaultModel or bind a persona with one)`);
+    const skillAgent = createAgent(() => ({ model, instructions: skill.body }));
+    const res2 = await invokeAgent({
+      agent: skillAgent,
+      agentName: `${def.name}/${step.id}`,
+      instanceId: `${parentRunId}/${step.id}`,
+      message,
+      persistence: ctx.persistence,
+      engine: ctx.engine,
+      env: ctx.env,
+      onEvent: ctx.onEvent,
+      baseInstructions: ctx.baseInstructions
+    });
+    return res2.text;
+  }
+  if (!agent) {
+    const model = step.model ?? profile?.model ?? ctx.defaultModel;
+    if (!model) throw new Error(`Step "${step.id}" needs a model (step.model, persona model, or workflow defaultModel)`);
+    const instructions = profile?.instructions;
+    agent = createAgent(() => ({ model, instructions }));
+  }
+  const res = await invokeAgent({
+    agent,
+    agentName: `${def.name}/${step.id}`,
+    instanceId: `${parentRunId}/${step.id}`,
+    message,
+    persistence: ctx.persistence,
+    engine: ctx.engine,
+    env: ctx.env,
+    onEvent: ctx.onEvent,
+    baseInstructions: ctx.baseInstructions
+  });
+  return res.text;
+}
+async function approveGate(def, ctx, runId, decision) {
+  const persistence = ctx.persistence ?? getDefaultPersistence();
+  const record2 = await persistence.runs.get(runId);
+  if (!record2) throw new Error(`No workflow run "${runId}"`);
+  if (record2.status !== "waiting_approval") throw new Error(`Run "${runId}" is not waiting for approval (status: ${record2.status})`);
+  const state = record2.state ?? { cursor: 0, results: {}, gates: {} };
+  const step = def.steps[state.cursor];
+  if (!step || step.kind !== "gate" || step.id !== decision.gate) {
+    throw new Error(`Run "${runId}" is waiting on gate "${step && step.kind === "gate" ? step.id : "?"}", not "${decision.gate}"`);
+  }
+  state.gates[decision.gate] = { approved: decision.approved, note: decision.note, at: Date.now() };
+  await persistence.runs.update(runId, { state });
+  return advanceWorkflow(def, ctx, runId);
+}
+async function recoverWorkflows(defs, ctx = {}) {
+  const persistence = ctx.persistence ?? getDefaultPersistence();
+  const running = await persistence.runs.list({ status: "running" });
+  const resumed = [];
+  for (const record2 of running) {
+    if (record2.kind !== "workflow") continue;
+    const def = defs[record2.agent];
+    if (!def) {
+      await persistence.runs.update(record2.runId, { status: "interrupted", endedAt: Date.now() });
+      continue;
+    }
+    void advanceWorkflow(def, { ...ctx, persistence }, record2.runId).catch(() => {
+    });
+    resumed.push(record2.runId);
+  }
+  return resumed;
+}
+function waitingGate(def, record2) {
+  if (record2.status !== "waiting_approval") return void 0;
+  const state = record2.state;
+  const step = state ? def.steps[state.cursor] : void 0;
+  return step?.kind === "gate" ? { id: step.id, title: step.title } : void 0;
+}
+
+// src/channel.ts
+function defineChannel(channel) {
+  return channel;
+}
+function isChannelDefinition(value) {
+  return Boolean(value && typeof value === "object" && typeof value.handle === "function");
+}
+async function verifyGithubWebhookSignature(secret, body, header) {
+  if (!secret || !header?.startsWith("sha256=")) return false;
+  const expected = "sha256=" + await hmacSha256Hex(secret, body);
+  return timingSafeEqual(expected, header);
+}
+async function verifySlackRequestSignature(secret, body, timestamp, signature, options = {}) {
+  if (!secret || !timestamp || !signature?.startsWith("v0=")) return false;
+  const now = options.now ?? Date.now();
+  const toleranceMs = options.toleranceMs ?? 5 * 60 * 1e3;
+  const ageMs = Math.abs(now - Number(timestamp) * 1e3);
+  if (!Number.isFinite(ageMs) || ageMs > toleranceMs) return false;
+  const expected = "v0=" + await hmacSha256Hex(secret, "v0:" + timestamp + ":" + body);
+  return timingSafeEqual(expected, signature);
+}
+async function hmacSha256Hex(secret, body) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const digest = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+// src/cron.ts
+function cronMatches(expr, date) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) throw new Error(`Invalid cron "${expr}": expected 5 fields, got ${fields.length}`);
+  const [minute, hour, dom, month, dow] = fields;
+  const domMatch = fieldMatches(dom, date.getUTCDate(), 1, 31);
+  const dowMatch = fieldMatches(dow, date.getUTCDay(), 0, 7, true);
+  const dayMatch = dom !== "*" && dow !== "*" ? domMatch || dowMatch : domMatch && dowMatch;
+  return fieldMatches(minute, date.getUTCMinutes(), 0, 59) && fieldMatches(hour, date.getUTCHours(), 0, 23) && dayMatch && fieldMatches(month, date.getUTCMonth() + 1, 1, 12);
+}
+function fieldMatches(field, value, min, max, isDow = false) {
+  const values = isDow && value === 0 ? [0, 7] : [value];
+  for (const part of field.split(",")) {
+    const m = part.match(/^(\*|\d+(?:-\d+)?)(?:\/(\d+))?$/);
+    if (!m) throw new Error(`Invalid cron field "${field}"`);
+    const [, range, stepStr] = m;
+    const step = stepStr ? Number(stepStr) : 1;
+    if (step < 1) throw new Error(`Invalid cron step in "${field}"`);
+    let lo = min;
+    let hi = max;
+    if (range !== "*") {
+      const [a, b] = range.split("-").map(Number);
+      lo = a;
+      hi = b ?? (stepStr ? max : a);
+    }
+    for (const v4 of values) {
+      if (v4 >= lo && v4 <= hi && (v4 - lo) % step === 0) return true;
+    }
+  }
+  return false;
+}
+function startCronScheduler(jobs, opts) {
+  if (jobs.length === 0) return () => {
+  };
+  let lastMinute = -1;
+  const tick = () => {
+    const now = /* @__PURE__ */ new Date();
+    const minuteKey = Math.floor(now.getTime() / 6e4);
+    if (minuteKey === lastMinute) return;
+    lastMinute = minuteKey;
+    for (const job of jobs) {
+      try {
+        if (cronMatches(job.cron, now)) {
+          Promise.resolve(job.run()).catch((err) => opts?.onError?.(err, job));
+        }
+      } catch (err) {
+        opts?.onError?.(err, job);
+      }
+    }
+  };
+  const timer = setInterval(tick, 15e3);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+export {
+  createAgent,
+  defineAgent,
+  isCreatedAgent,
+  defineAgentProfile,
+  applyProfile,
+  ToolApprovalRequiredError,
+  isToolApprovalRequiredError,
+  attachToolApprovalPartialTranscript,
+  waitingToolApproval,
+  decideToolApprovalState,
+  builtinTools,
+  BUILTIN_TOOL_NAMES,
+  isWorkspaceSkill,
+  discoverSessionContext,
+  loadWorkspaceSkill,
+  parseSkillMarkdown,
+  RuleViolation,
+  makeRuleGuard,
+  emptyUsage,
+  addUsage,
+  PiAgentEngine,
+  envApiKeyFor,
+  EngineError,
+  EventBus,
+  observe,
+  makeCall,
+  defineTool,
+  rawTool,
+  isRawTool,
+  resolveTool,
+  resolveAnyTool,
+  Session,
+  Harness,
+  defaultEngine,
+  getDefaultPersistence,
+  genId,
+  dispatchWorkflow,
+  recoverRuns,
+  invokeAgent,
+  WorkflowDefSchema,
+  parseWorkflowDef,
+  startWorkflow,
+  advanceWorkflow,
+  approveGate,
+  recoverWorkflows,
+  waitingGate,
+  defineChannel,
+  isChannelDefinition,
+  verifyGithubWebhookSignature,
+  verifySlackRequestSignature,
+  cronMatches,
+  startCronScheduler
+};