@aiaiai-pt/martha-cli 0.20.0 → 0.23.0

package/dist/index.js

@@ -11077,7 +11077,7 @@ import { createInterface as createInterface2 } from "node:readline";
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.20.0";
+var CLI_VERSION = "0.23.0";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -11349,7 +11349,768 @@ function createApprovalTagStripper() {
   };
 }
 
+// src/lib/local-exec.ts
+import { spawn } from "node:child_process";
+import { closeSync, openSync, promises as fs5 } from "node:fs";
+import * as path4 from "node:path";
+var DEFAULT_TIMEOUT_MS = 20000;
+var MAX_OUTPUT = 256 * 1024;
+function runnerDir(cwd) {
+  return path4.join(cwd, ".martha-runner");
+}
+async function runHostCommand(command, toolCallId, opts) {
+  const dir = runnerDir(opts.cwd);
+  await fs5.mkdir(dir, { recursive: true });
+  const logPath = path4.join(dir, `${safeName(toolCallId)}.log`);
+  await fs5.writeFile(logPath, "");
+  const fd = openSync(logPath, "a");
+  const cap = opts.maxOutputBytes ?? MAX_OUTPUT;
+  const readLog = async () => {
+    try {
+      const buf = await fs5.readFile(logPath);
+      return buf.subarray(-cap).toString("utf8");
+    } catch {
+      return "";
+    }
+  };
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const child = spawn(command, {
+      shell: true,
+      cwd: opts.cwd,
+      detached: true,
+      stdio: ["ignore", fd, fd]
+    });
+    closeSync(fd);
+    const timer = setTimeout(async () => {
+      if (settled)
+        return;
+      settled = true;
+      child.unref();
+      resolve({
+        stdout: await readLog(),
+        stderr: "",
+        exit_code: 0,
+        backgrounded: true,
+        pid: child.pid
+      });
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    child.on("error", (e) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", async (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ stdout: await readLog(), stderr: "", exit_code: code ?? -1 });
+    });
+  });
+}
+function safeName(s) {
+  return s.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 120) || "task";
+}
+
+class Journal {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  file() {
+    return path4.join(runnerDir(this.cwd), "journal.json");
+  }
+  async load() {
+    try {
+      return JSON.parse(await fs5.readFile(this.file(), "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  async save(data) {
+    await fs5.mkdir(runnerDir(this.cwd), { recursive: true });
+    await fs5.writeFile(this.file(), JSON.stringify(data, null, 2));
+  }
+  static key(sessionId, toolCallId) {
+    return `${sessionId}:${toolCallId}`;
+  }
+  async lookup(sessionId, toolCallId) {
+    return (await this.load())[Journal.key(sessionId, toolCallId)];
+  }
+  async recordRunning(sessionId, toolCallId, command, now) {
+    const data = await this.load();
+    data[Journal.key(sessionId, toolCallId)] = {
+      state: "running",
+      command,
+      started_at: now
+    };
+    await this.save(data);
+  }
+  async recordDone(sessionId, toolCallId, result) {
+    const data = await this.load();
+    const k = Journal.key(sessionId, toolCallId);
+    const prev = data[k];
+    data[k] = {
+      state: "done",
+      command: prev?.command ?? "",
+      started_at: prev?.started_at ?? "",
+      result
+    };
+    await this.save(data);
+  }
+}
+function decideFromJournal(entry) {
+  if (!entry)
+    return { kind: "fresh" };
+  if (entry.state === "done" && entry.result)
+    return { kind: "replay", result: entry.result };
+  return { kind: "crashed", command: entry.command };
+}
+function parseHostExecRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "host_exec" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id)
+      continue;
+    out.push({ toolCallId: t.tool_call_id, command: t.args?.command ?? "" });
+  }
+  return out;
+}
+
+// src/lib/host-screenshot.ts
+async function captureScreenshot(url, opts) {
+  const moduleName = "playwright";
+  let chromium;
+  try {
+    ({ chromium } = await import(moduleName));
+  } catch {
+    throw new Error("playwright is not installed on the runner. Install it to use host_screenshot: `npm i -D playwright && npx playwright install chromium`");
+  }
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(url, { waitUntil: "load", timeout: 30000 });
+    if (opts.waitMs > 0)
+      await page.waitForTimeout(opts.waitMs);
+    const buf = await page.screenshot({
+      fullPage: opts.fullPage,
+      type: "png"
+    });
+    return buf;
+  } finally {
+    await browser.close();
+  }
+}
+function parseHostScreenshotRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "host_screenshot" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id || !t.args?.url)
+      continue;
+    out.push({
+      toolCallId: t.tool_call_id,
+      url: t.args.url,
+      fullPage: t.args.full_page !== false,
+      waitMs: typeof t.args.wait_ms === "number" ? t.args.wait_ms : 500
+    });
+  }
+  return out;
+}
+
+// src/lib/host-browser.ts
+var DOM_CAP = 16 * 1024;
+var CONSOLE_CAP = 200;
+function parseHostBrowserRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const valid = [
+    "navigate",
+    "click",
+    "read_console",
+    "read_dom",
+    "screenshot"
+  ];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "host_browser" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id)
+      continue;
+    const action = t.args?.action;
+    if (!action || !valid.includes(action))
+      continue;
+    out.push({
+      toolCallId: t.tool_call_id,
+      action,
+      url: t.args?.url,
+      selector: t.args?.selector,
+      waitMs: typeof t.args?.wait_ms === "number" ? t.args.wait_ms : 500,
+      fullPage: t.args?.full_page !== false
+    });
+  }
+  return out;
+}
+async function applyBrowserAction(page, consoleBuffer, req) {
+  try {
+    switch (req.action) {
+      case "navigate": {
+        if (!req.url)
+          return { error: true, message: "navigate requires `url`" };
+        await page.goto(req.url, { waitUntil: "load", timeout: 30000 });
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const title = await page.title();
+        const url = page.url();
+        return { text: `Navigated to ${url} (title: ${title || "<none>"}).` };
+      }
+      case "click": {
+        if (!req.selector)
+          return { error: true, message: "click requires `selector`" };
+        await page.click(req.selector, { timeout: 1e4 });
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        return { text: `Clicked ${req.selector}.` };
+      }
+      case "read_console": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const entries = consoleBuffer.slice(-CONSOLE_CAP);
+        if (entries.length === 0)
+          return {
+            text: "No console messages, page errors, or failed requests captured yet."
+          };
+        const lines = entries.map((e) => {
+          if (e.kind === "console")
+            return `[console.${e.level}] ${e.text}`;
+          if (e.kind === "pageerror")
+            return `[pageerror] ${e.text}`;
+          return `[requestfailed] ${e.url} — ${e.text}`;
+        });
+        return {
+          text: `Captured ${entries.length} console/error/network entries:
+${lines.join(`
+`)}`
+        };
+      }
+      case "read_dom": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        let html;
+        if (req.selector) {
+          html = await page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            return el ? el.outerHTML : `__NOT_FOUND__:${sel}`;
+          }, req.selector);
+          if (typeof html === "string" && html.startsWith("__NOT_FOUND__:"))
+            return {
+              error: true,
+              message: `No element matched selector: ${req.selector}`
+            };
+        } else {
+          html = await page.content();
+        }
+        const truncated = html.length > DOM_CAP;
+        return {
+          text: (truncated ? html.slice(0, DOM_CAP) + `
+…[truncated]` : html) || ""
+        };
+      }
+      case "screenshot": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const buf = await page.screenshot({
+          fullPage: req.fullPage,
+          type: "png"
+        });
+        return { png: buf };
+      }
+      default:
+        return { error: true, message: `unknown action: ${req.action}` };
+    }
+  } catch (e) {
+    return { error: true, message: `${req.action} failed: ${String(e)}` };
+  }
+}
+
+class BrowserSession {
+  browser = null;
+  page = null;
+  consoleBuffer = [];
+  async ensurePage() {
+    if (this.page)
+      return this.page;
+    const moduleName = "playwright";
+    let chromium;
+    try {
+      ({ chromium } = await import(moduleName));
+    } catch {
+      throw new Error("playwright is not installed on the runner. Install it to use host_browser: `npm i -D playwright && npx playwright install chromium`");
+    }
+    this.browser = await chromium.launch({ headless: true });
+    this.page = await this.browser.newPage();
+    this.page.on("console", (msg) => this.consoleBuffer.push({
+      kind: "console",
+      level: msg.type(),
+      text: msg.text()
+    }));
+    this.page.on("pageerror", (err) => this.consoleBuffer.push({
+      kind: "pageerror",
+      text: String(err?.message ?? err)
+    }));
+    this.page.on("requestfailed", (request) => this.consoleBuffer.push({
+      kind: "requestfailed",
+      url: request.url(),
+      text: request.failure()?.errorText ?? "failed"
+    }));
+    return this.page;
+  }
+  async run(req) {
+    let page;
+    try {
+      page = await this.ensurePage();
+    } catch (e) {
+      return { error: true, message: String(e) };
+    }
+    return applyBrowserAction(page, this.consoleBuffer, req);
+  }
+  async close() {
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch {}
+      this.browser = null;
+      this.page = null;
+    }
+  }
+}
+
+// src/lib/host-files.ts
+import { promises as fs6 } from "node:fs";
+import * as path5 from "node:path";
+var READ_CAP = 256 * 1024;
+function resolvePath(cwd, p) {
+  return path5.isAbsolute(p) ? p : path5.resolve(cwd, p);
+}
+async function applyFileAction(cwd, req) {
+  if (!req.path)
+    return { error: true, message: `${req.action} requires \`path\`` };
+  const abs = resolvePath(cwd, req.path);
+  try {
+    switch (req.action) {
+      case "host_read": {
+        const raw = await fs6.readFile(abs, "utf8");
+        let body = raw;
+        if (typeof req.offset === "number" || typeof req.limit === "number") {
+          const lines = raw.split(`
+`);
+          const start = Math.max(0, (req.offset ?? 1) - 1);
+          const end = typeof req.limit === "number" ? start + req.limit : lines.length;
+          body = lines.slice(start, end).join(`
+`);
+        }
+        const truncated = body.length > READ_CAP;
+        if (truncated)
+          body = body.slice(0, READ_CAP) + `
+…[truncated]`;
+        return { text: body === "" ? "(empty file)" : body };
+      }
+      case "host_write": {
+        if (typeof req.content !== "string")
+          return { error: true, message: "host_write requires `content`" };
+        await fs6.mkdir(path5.dirname(abs), { recursive: true });
+        await fs6.writeFile(abs, req.content, "utf8");
+        return {
+          text: `Wrote ${Buffer.byteLength(req.content, "utf8")} bytes to ${req.path}.`
+        };
+      }
+      case "host_edit": {
+        if (typeof req.oldString !== "string" || typeof req.newString !== "string")
+          return {
+            error: true,
+            message: "host_edit requires `old_string` and `new_string`"
+          };
+        if (req.oldString === req.newString)
+          return {
+            error: true,
+            message: "old_string and new_string are identical"
+          };
+        const raw = await fs6.readFile(abs, "utf8");
+        const count = req.oldString ? raw.split(req.oldString).length - 1 : 0;
+        if (count === 0)
+          return { error: true, message: "old_string not found in file" };
+        if (count > 1 && !req.replaceAll)
+          return {
+            error: true,
+            message: `old_string is not unique (${count} matches); pass replace_all=true to replace all`
+          };
+        const next = req.replaceAll ? raw.split(req.oldString).join(req.newString) : raw.replace(req.oldString, req.newString);
+        await fs6.writeFile(abs, next, "utf8");
+        return {
+          text: `Edited ${req.path} (${req.replaceAll ? count : 1} replacement${(req.replaceAll ? count : 1) === 1 ? "" : "s"}).`
+        };
+      }
+      default:
+        return { error: true, message: `unknown file action: ${req.action}` };
+    }
+  } catch (e) {
+    return { error: true, message: `${req.action} failed: ${String(e)}` };
+  }
+}
+var VALID = ["host_read", "host_write", "host_edit"];
+function parseHostFileRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.status !== "awaiting_input" || !t.tool_call_id)
+      continue;
+    if (!VALID.includes(t.tool_name))
+      continue;
+    const a = t.args ?? {};
+    out.push({
+      toolCallId: t.tool_call_id,
+      action: t.tool_name,
+      path: a.path,
+      offset: typeof a.offset === "number" ? a.offset : undefined,
+      limit: typeof a.limit === "number" ? a.limit : undefined,
+      content: typeof a.content === "string" ? a.content : undefined,
+      oldString: typeof a.old_string === "string" ? a.old_string : undefined,
+      newString: typeof a.new_string === "string" ? a.new_string : undefined,
+      replaceAll: a.replace_all === true
+    });
+  }
+  return out;
+}
+
+// src/lib/local-agent.ts
+import { spawn as spawn2 } from "node:child_process";
+var DEFAULT_LOCAL_AGENT_CMD = "codex exec";
+var DEFAULT_LOCAL_AGENT_TIMEOUT_MS = 30 * 60 * 1000;
+var MAX_OUTPUT2 = 256 * 1024;
+function buildAgentArgv(agentCmd, task) {
+  const parts = agentCmd.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0)
+    throw new Error("MARTHA_LOCAL_AGENT_CMD is empty");
+  return [...parts, task];
+}
+async function runLocalAgent(task, opts) {
+  const argv = buildAgentArgv(opts.agentCmd, task);
+  const cap = opts.maxOutputBytes ?? MAX_OUTPUT2;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_LOCAL_AGENT_TIMEOUT_MS;
+  return await new Promise((resolve2, reject) => {
+    let out = "";
+    let settled = false;
+    let child;
+    try {
+      child = spawn2(argv[0], argv.slice(1), {
+        cwd: opts.cwd,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    const append = (chunk) => {
+      if (out.length < cap)
+        out += chunk.toString("utf8");
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      child.kill("SIGKILL");
+      resolve2({
+        text: out.slice(0, cap),
+        exit_code: -1,
+        timed_out: true
+      });
+    }, timeoutMs);
+    child.on("error", (e) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2({ text: out.slice(0, cap), exit_code: code ?? -1 });
+    });
+  });
+}
+function parseLocalAgentRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "local_agent" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id || !t.args?.task)
+      continue;
+    out.push({
+      toolCallId: t.tool_call_id,
+      task: t.args.task,
+      cwd: typeof t.args.cwd === "string" ? t.args.cwd : undefined
+    });
+  }
+  return out;
+}
+
 // src/commands/chat.ts
+async function uploadImageArtifact(ctx, sessionId, png) {
+  try {
+    const mint = await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/local-artifact-upload`, {
+      content_type: "image/png"
+    });
+    const put = await fetch(mint.upload_url, {
+      method: "PUT",
+      headers: { "Content-Type": "image/png" },
+      body: new Uint8Array(png)
+    });
+    if (!put.ok)
+      return { error: `image upload failed: HTTP ${put.status}` };
+    return { storage_key: mint.storage_key };
+  } catch (e) {
+    return { error: `image upload failed: ${String(e)}` };
+  }
+}
+async function resolveHostExec(sessionId, toolCallId, command, state) {
+  const decision = decideFromJournal(await state.journal.lookup(sessionId, toolCallId));
+  if (decision.kind === "replay")
+    return decision.result;
+  if (decision.kind === "crashed") {
+    return {
+      error: true,
+      exit_code: -1,
+      message: `A previous run did not complete; not re-running: ${decision.command}`
+    };
+  }
+  if (!state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[host_exec] refused (re-run with --yes to allow): ${command}
+`));
+    return {
+      declined: true,
+      exit_code: -1,
+      message: "Host execution declined; re-run with --yes to allow."
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[host_exec] $ ${command}
+  (cwd: ${state.cwd})
+`));
+  await state.journal.recordRunning(sessionId, toolCallId, command, new Date().toISOString());
+  let result;
+  try {
+    result = await runHostCommand(command, toolCallId, { cwd: state.cwd });
+  } catch (e) {
+    result = { stdout: "", stderr: String(e), exit_code: -1 };
+  }
+  await state.journal.recordDone(sessionId, toolCallId, result);
+  return result;
+}
+async function resolveHostScreenshot(ctx, sessionId, req, state) {
+  if (!state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[host_screenshot] refused (re-run with --yes to allow): ${req.url}
+`));
+    return {
+      declined: true,
+      message: "Host screenshot declined; re-run with --yes to allow."
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[host_screenshot] ${req.url}
+`));
+  let png;
+  try {
+    png = await captureScreenshot(req.url, {
+      fullPage: req.fullPage,
+      waitMs: req.waitMs
+    });
+  } catch (e) {
+    return { error: true, message: `screenshot failed: ${String(e)}` };
+  }
+  const uploaded = await uploadImageArtifact(ctx, sessionId, png);
+  if ("error" in uploaded)
+    return { error: true, message: uploaded.error };
+  return {
+    text: `Screenshot of ${req.url} captured (${png.length} bytes).`,
+    _images: [{ storage_key: uploaded.storage_key }]
+  };
+}
+async function resolveHostBrowser(ctx, sessionId, req, state) {
+  if (!state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[host_browser] refused (re-run with --yes to allow): ${req.action}${req.url ? ` ${req.url}` : ""}
+`));
+    return {
+      declined: true,
+      message: "Host browser declined; re-run with --yes to allow."
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[host_browser] ${req.action}${req.url ? ` ${req.url}` : ""}${req.selector ? ` (${req.selector})` : ""}
+`));
+  if (!state.browser)
+    state.browser = new BrowserSession;
+  const result = await state.browser.run(req);
+  if ("error" in result)
+    return { error: true, message: result.message };
+  if ("png" in result) {
+    const uploaded = await uploadImageArtifact(ctx, sessionId, result.png);
+    if ("error" in uploaded)
+      return { error: true, message: uploaded.error };
+    return {
+      text: `Screenshot of the current page captured (${result.png.length} bytes).`,
+      _images: [{ storage_key: uploaded.storage_key }]
+    };
+  }
+  return result;
+}
+async function resolveHostFile(req, state) {
+  const mutating = req.action === "host_write" || req.action === "host_edit";
+  if (mutating && !state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[${req.action}] refused (re-run with --yes to allow): ${req.path}
+`));
+    return {
+      declined: true,
+      message: `${req.action} declined; re-run with --yes to allow.`
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[${req.action}] ${req.path ?? "<no path>"}
+`));
+  const result = await applyFileAction(state.cwd, req);
+  if ("error" in result)
+    return { error: true, message: result.message };
+  return result;
+}
+async function resolveLocalAgent(req, state) {
+  if (!state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[local_agent] refused (re-run with --yes to allow): ${req.task.slice(0, 80)}
+`));
+    return {
+      declined: true,
+      message: "Local agent delegation declined; re-run with --yes to allow."
+    };
+  }
+  const agentCmd = process.env.MARTHA_LOCAL_AGENT_CMD || DEFAULT_LOCAL_AGENT_CMD;
+  const cwd = req.cwd ? `${state.cwd}/${req.cwd}` : state.cwd;
+  process.stderr.write(source_default.dim(`
+[local_agent] (${agentCmd}) ${req.task.slice(0, 100)}
+`));
+  try {
+    const result = await runLocalAgent(req.task, { cwd, agentCmd });
+    return {
+      text: result.text || "(local agent produced no output)",
+      exit_code: result.exit_code,
+      ...result.timed_out ? { timed_out: true } : {}
+    };
+  } catch (e) {
+    return {
+      error: true,
+      message: `local agent failed to start (${agentCmd}): ${String(e)}. ` + `Set MARTHA_LOCAL_AGENT_CMD to an installed agent command.`
+    };
+  }
+}
+async function _postToolResult(ctx, sessionId, toolCallId, result, label) {
+  try {
+    await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/tool-result`, { tool_call_id: toolCallId, result });
+  } catch (e) {
+    process.stderr.write(source_default.red(`[${label}] failed to POST result: ${String(e)}
+`));
+  }
+}
+async function handleHostExecFrame(ctx, sessionId, data, state) {
+  for (const req of parseHostExecRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostExec(sessionId, id, req.command, state);
+    await _postToolResult(ctx, sessionId, id, result, "host_exec");
+  }
+  for (const req of parseHostScreenshotRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostScreenshot(ctx, sessionId, req, state);
+    await _postToolResult(ctx, sessionId, id, result, "host_screenshot");
+  }
+  for (const req of parseHostBrowserRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostBrowser(ctx, sessionId, req, state);
+    await _postToolResult(ctx, sessionId, id, result, "host_browser");
+  }
+  for (const req of parseHostFileRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostFile(req, state);
+    await _postToolResult(ctx, sessionId, id, result, req.action);
+  }
+  for (const req of parseLocalAgentRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveLocalAgent(req, state);
+    await _postToolResult(ctx, sessionId, id, result, "local_agent");
+  }
+}
 function parseSlashCommand(input) {
   const trimmed = input.trim();
   if (!trimmed.startsWith("/"))
@@ -11400,7 +12161,16 @@ async function sendMessage(ctx, sessionId, message, opts = {}) {
       params.selected_agent = opts.agentName;
     reqOpts.params = params;
   }
-  const res = await ctx.api.postRaw(`/api/chat/${encodeURIComponent(sessionId)}`, { content: message }, reqOpts);
+  const localExecState = opts.localExec ? {
+    cwd: opts.localExec.cwd,
+    autoYes: opts.localExec.autoYes,
+    handled: new Set,
+    journal: new Journal(opts.localExec.cwd)
+  } : null;
+  const reqBody = { content: message };
+  if (opts.localExec)
+    reqBody.capability_keys = ["local_exec"];
+  const res = await ctx.api.postRaw(`/api/chat/${encodeURIComponent(sessionId)}`, reqBody, reqOpts);
   const contentType = res.headers.get("content-type") ?? "";
   let fullResponse = "";
   if (contentType.includes("application/json")) {
@@ -11448,6 +12218,9 @@ async function sendMessage(ctx, sessionId, message, opts = {}) {
           case "tool_status":
             if (opts.onToolStatus)
               opts.onToolStatus(event.data);
+            if (localExecState) {
+              await handleHostExecFrame(ctx, sessionId, event.data, localExecState);
+            }
             break;
           case "clear":
             fullResponse = "";
@@ -11461,6 +12234,9 @@ async function sendMessage(ctx, sessionId, message, opts = {}) {
         return { response: fullResponse, aborted: true };
       }
       throw err;
+    } finally {
+      if (localExecState?.browser)
+        await localExecState.browser.close();
     }
   } else {
     const text = await res.text();
@@ -11511,11 +12287,11 @@ function formatToolStatus(data) {
   }
 }
 function promptPick(rl, count) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(source_default.dim(`Pick 1-${count} (or Enter to cancel): `), (ans) => {
       const trimmed = ans.trim();
       if (!trimmed) {
-        resolve(-1);
+        resolve2(-1);
         return;
       }
       const n = parseInt(trimmed, 10);
@@ -11523,10 +12299,10 @@ function promptPick(rl, count) {
         process.stderr.write(source_default.yellow(`Invalid choice.
 
 `));
-        resolve(-1);
+        resolve2(-1);
         return;
       }
-      resolve(n - 1);
+      resolve2(n - 1);
     });
   });
 }
@@ -11668,7 +12444,7 @@ async function showHistoryPicker(ctx, rl) {
   }
   return data.items[idx].session_id;
 }
-async function runRepl(ctx, initialSessionId, clientId, agentName, showTools, timeoutMs) {
+async function runRepl(ctx, initialSessionId, clientId, agentName, showTools, timeoutMs, localExec) {
   let sessionId = initialSessionId;
   process.stderr.write(source_default.dim(`martha v${CLI_VERSION} | session: ${sessionId.slice(0, 8)}...
 `));
@@ -11805,6 +12581,7 @@ Cancelled.
     try {
       const result = await sendMessage(ctx, sessionId, input, {
         timeoutMs,
+        localExec,
         onToken: (token) => process.stdout.write(stripper.push(token)),
         onToolCall: showTools ? (data) => process.stderr.write(formatToolCall(data)) : undefined,
         onToolResult: (data) => {
@@ -11860,7 +12637,7 @@ Error: ${err instanceof Error ? err.message : String(err)}
   process.stderr.write(`
 `);
 }
-async function runOneShot(ctx, sessionId, message, isJson, clientId, agentName, showTools, timeoutMs) {
+async function runOneShot(ctx, sessionId, message, isJson, clientId, agentName, showTools, timeoutMs, localExec) {
   const toolCalls = [];
   function recordToolStatus(data) {
     try {
@@ -11884,6 +12661,7 @@ async function runOneShot(ctx, sessionId, message, isJson, clientId, agentName,
     clientId,
     agentName,
     timeoutMs,
+    localExec,
     onToolStatus: isJson ? recordToolStatus : showTools ? (data) => {
       recordToolStatus(data);
       process.stderr.write(formatToolStatus(data));
@@ -11907,7 +12685,7 @@ async function runOneShot(ctx, sessionId, message, isJson, clientId, agentName,
   }
 }
 function registerChatCommand(program2) {
-  program2.command("chat").description("Chat with a Martha agent").option("--session <id>", "Resume an existing session").option("--client <nameOrId>", "Use a specific client (name or ID)").option("--agent <name>", "Drive the chat with a specific copilot agent (defaults to profile.default_agent)").option("--message <text>", "Send a single message (non-interactive)").option("--show-tools", "Show tool calls and results during chat").option("--timeout <seconds>", "Per-message HTTP timeout in seconds (default: 600)").action(async (opts) => {
+  program2.command("chat").description("Chat with a Martha agent").option("--session <id>", "Resume an existing session").option("--client <nameOrId>", "Use a specific client (name or ID)").option("--agent <name>", "Drive the chat with a specific copilot agent (defaults to profile.default_agent)").option("--message <text>", "Send a single message (non-interactive)").option("--show-tools", "Show tool calls and results during chat").option("--local-exec", "Allow the agent to run host tools on THIS machine (#568). Requires the server to have LOCAL_EXEC_ENABLED=1.").option("--yes", "Auto-approve host tool execution (required with --local-exec for non-interactive runs).").option("--timeout <seconds>", "Per-message HTTP timeout in seconds (default: 600)").action(async (opts) => {
     const ctx = createContext({
       profileOverride: program2.opts().profile,
       verbose: program2.opts().verbose
@@ -11942,13 +12720,14 @@ function registerChatCommand(program2) {
     }
     const showTools = !!opts.showTools;
     const timeoutMs = opts.timeout ? parseTimeoutSeconds(opts.timeout) * 1000 : undefined;
+    const localExec = opts.localExec ? { cwd: process.cwd(), autoYes: !!opts.yes } : undefined;
     if (opts.message) {
-      await runOneShot(ctx, sessionId, opts.message, isJson, clientId, agentName, showTools, timeoutMs);
+      await runOneShot(ctx, sessionId, opts.message, isJson, clientId, agentName, showTools, timeoutMs, localExec);
     } else {
       if (isJson) {
         throw new CLIError("The --json flag requires --message for non-interactive mode.", 4 /* Validation */, 'Example: martha --json chat --message "hello"');
       }
-      await runRepl(ctx, sessionId, clientId, agentName, showTools, timeoutMs);
+      await runRepl(ctx, sessionId, clientId, agentName, showTools, timeoutMs, localExec);
     }
   });
 }
@@ -11966,9 +12745,9 @@ init_errors();
 import { createInterface as createInterface3 } from "node:readline";
 function prompt(rl, question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${question}${suffix}: `, (answer) => {
-      resolve(answer.trim() || defaultValue || "");
+      resolve2(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -12264,14 +13043,14 @@ function registerConfigCommand(program2) {
       if (!process.stdin.isTTY) {
         throw new CLIError("Cannot confirm in non-interactive mode.", 4 /* Validation */, "Use --yes to skip confirmation.");
       }
-      const ok = await new Promise((resolve) => {
+      const ok = await new Promise((resolve2) => {
         const rl = createInterface3({
           input: process.stdin,
           output: process.stderr
         });
         rl.question(`Delete profile '${name}'? (y/N) `, (answer) => {
           rl.close();
-          resolve(answer.trim().toLowerCase() === "y");
+          resolve2(answer.trim().toLowerCase() === "y");
         });
       });
       if (!ok) {
@@ -12294,20 +13073,27 @@ function registerConfigCommand(program2) {
 }
 
 // src/commands/definitions-apply.ts
-import fs5 from "node:fs";
-import path4 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 init_dist();
 init_errors();
-var VALID_KINDS = new Set(["Function", "Workflow", "Agent"]);
+var VALID_KINDS = new Set([
+  "Function",
+  "Workflow",
+  "Agent",
+  "Trigger"
+]);
 var KIND_TO_API_PATH = {
   Function: "/api/admin/definitions/functions",
   Workflow: "/api/admin/definitions/workflows",
-  Agent: "/api/admin/definitions/agents"
+  Agent: "/api/admin/definitions/agents",
+  Trigger: "/api/admin/triggers"
 };
 var KIND_TO_PLURAL = {
   Function: "Functions",
   Workflow: "Workflows",
-  Agent: "Agents"
+  Agent: "Agents",
+  Trigger: "Triggers"
 };
 var SERVER_GENERATED_FIELDS = new Set([
   "id",
@@ -12330,20 +13116,20 @@ var SERVER_GENERATED_FIELDS = new Set([
 ]);
 var AGENT_MANAGED_FIELDS = new Set(["functions", "workflows"]);
 function loadDefinitions(inputPath) {
-  const resolved = path4.resolve(inputPath);
-  if (!fs5.existsSync(resolved)) {
+  const resolved = path6.resolve(inputPath);
+  if (!fs7.existsSync(resolved)) {
     throw new CLIError(`Path not found: ${inputPath}`, 1 /* Error */);
   }
-  const stat = fs5.statSync(resolved);
+  const stat = fs7.statSync(resolved);
   if (stat.isDirectory()) {
     return loadDirectory(resolved);
   }
   return loadFile(resolved);
 }
 function loadDirectory(dirPath) {
-  const entries = fs5.readdirSync(dirPath).sort();
+  const entries = fs7.readdirSync(dirPath).sort();
   const validExts = new Set([".yaml", ".yml", ".json"]);
-  const files = entries.filter((e) => validExts.has(path4.extname(e).toLowerCase())).map((e) => path4.join(dirPath, e));
+  const files = entries.filter((e) => validExts.has(path6.extname(e).toLowerCase())).map((e) => path6.join(dirPath, e));
   if (files.length === 0) {
     throw new CLIError(`No YAML or JSON files found in ${dirPath}`, 4 /* Validation */);
   }
@@ -12354,8 +13140,8 @@ function loadDirectory(dirPath) {
   return results;
 }
 function loadFile(filePath) {
-  const content = fs5.readFileSync(filePath, "utf-8");
-  const ext = path4.extname(filePath).toLowerCase();
+  const content = fs7.readFileSync(filePath, "utf-8");
+  const ext = path6.extname(filePath).toLowerCase();
   if (ext === ".json") {
     const parsed = parseJsonFile(content, filePath);
     return [toLocalDefinition(parsed, filePath)];
@@ -12777,7 +13563,7 @@ Examples:
 }
 
 // src/commands/definitions-export.ts
-import fs6 from "node:fs";
+import fs8 from "node:fs";
 init_errors();
 async function exportDefinitions(ctx, opts, isJsonMode) {
   const params = {};
@@ -12793,7 +13579,7 @@ async function exportDefinitions(ctx, opts, isJsonMode) {
   const text = await res.text();
   if (opts.output) {
     try {
-      fs6.writeFileSync(opts.output, text);
+      fs8.writeFileSync(opts.output, text);
     } catch (err) {
       throw new CLIError(`Failed to write ${opts.output}: ${err instanceof Error ? err.message : String(err)}`, 1 /* Error */);
     }
@@ -13102,7 +13888,7 @@ function colorStatus(status) {
   return fn(status);
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function pollUntilDone(ctx, executionId, intervalMs = 2000, timeoutMs = 300000) {
   const deadline = Date.now() + timeoutMs;
@@ -13513,8 +14299,8 @@ function registerProjectionCommands(parentCmd, getCtx, isJson) {
       } catch {}
     }
     if (opts.output) {
-      const fs7 = await import("node:fs/promises");
-      await fs7.writeFile(opts.output, toWrite, "utf-8");
+      const fs9 = await import("node:fs/promises");
+      await fs9.writeFile(opts.output, toWrite, "utf-8");
       if (!isJson()) {
         console.error(source_default.dim(`Wrote ${format} projection of '${name}' to ${opts.output}`));
       }
@@ -13921,8 +14707,8 @@ Usage:
     });
     parentCmd.command("self-grant <agent>").description("View or configure an agent's self-provisioning policy (request-then-approve). " + "With no flags, prints the current policy.").option("--enable", "Allow the agent to REQUEST capability grants").option("--disable", "Disallow self-provisioning").option("--scope <scope>", "Scope ceiling: none | read_only | read_write").option("--allow <ref...>", "Add allow-list refs (function:NAME or mcp:integration/name)").option("--remove <ref...>", "Remove allow-list refs").option("--collection-root <id...>", "Add collection-subtree roots the agent may self-grant collection-scoped functions into").option("--remove-collection-root <id...>", "Remove collection roots").option("--max-pending <n>", "Max concurrently-pending requests").action(async (agent, opts) => {
       const ctx = getCtx();
-      const path5 = `${API_PATH}/${encodeURIComponent(agent)}`;
-      const current = await ctx.api.get(path5);
+      const path7 = `${API_PATH}/${encodeURIComponent(agent)}`;
+      const current = await ctx.api.get(path7);
       const mutating = opts.enable || opts.disable || opts.scope !== undefined || (opts.allow?.length ?? 0) > 0 || (opts.remove?.length ?? 0) > 0 || (opts.collectionRoot?.length ?? 0) > 0 || (opts.removeCollectionRoot?.length ?? 0) > 0 || opts.maxPending !== undefined;
       if (!mutating) {
         if (isJson()) {
@@ -13974,7 +14760,7 @@ Usage:
           roots.delete(c);
         body.self_grant_collection_roots = [...roots];
       }
-      const updated = await ctx.api.put(path5, body);
+      const updated = await ctx.api.put(path7, body);
       if (isJson()) {
         console.log(JSON.stringify(policyView(updated), null, 2));
         return;
@@ -13986,8 +14772,120 @@ Usage:
   }
 };
 
+// src/commands/triggers.ts
+init_errors();
+function triggerKind(item) {
+  if (item.schedule_config)
+    return "schedule";
+  if (item.deadman_config)
+    return "deadman";
+  return "event";
+}
+function scheduleSummary(sched) {
+  return String(sched.cron ?? sched.interval ?? sched.spec ?? "schedule");
+}
+var triggersConfig = {
+  typeName: "trigger",
+  typeNamePlural: "triggers",
+  apiPath: "/api/admin/triggers",
+  extractList: (data) => {
+    if (!Array.isArray(data)) {
+      throw new Error("Unexpected API response shape for triggers list");
+    }
+    return data;
+  },
+  listColumns: [
+    { header: "NAME", accessor: (item) => String(item.name ?? "") },
+    { header: "KIND", accessor: (item) => triggerKind(item) },
+    {
+      header: "EVENT / SCHEDULE",
+      accessor: (item) => {
+        const sched = item.schedule_config;
+        if (sched)
+          return scheduleSummary(sched);
+        return String(item.event_type ?? "-");
+      }
+    },
+    { header: "TARGET", accessor: (item) => String(item.target_name ?? "-") },
+    {
+      header: "STATUS",
+      accessor: (item) => item.is_active !== false ? "active" : "inactive"
+    }
+  ],
+  renderDetail: (t) => {
+    console.log(source_default.bold(`Trigger: ${t.name}
+`));
+    if (t.description)
+      console.log(`  ${t.description}
+`);
+    console.log(`  Kind:        ${triggerKind(t)}`);
+    console.log(`  Status:      ${t.is_active !== false ? source_default.green("active") : source_default.dim("inactive")}`);
+    if (t.event_type)
+      console.log(`  Event type:  ${t.event_type}`);
+    const filter = t.event_filter;
+    if (filter && Object.keys(filter).length)
+      console.log(`  Event filter: ${JSON.stringify(filter)}`);
+    const sched = t.schedule_config;
+    if (sched)
+      console.log(`  Schedule:    ${scheduleSummary(sched)}  ${source_default.dim(JSON.stringify(sched))}`);
+    const deadman = t.deadman_config;
+    if (deadman)
+      console.log(`  Deadman:     ${JSON.stringify(deadman)}`);
+    console.log(`  Target:      ${t.target_type ?? "workflow"} → ${t.target_name ?? "-"}`);
+    const mapping = t.input_mapping;
+    if (mapping && Object.keys(mapping).length) {
+      console.log(`
+  ${source_default.bold("Input mapping:")}`);
+      for (const [k, v] of Object.entries(mapping)) {
+        console.log(`    ${k.padEnd(20)} ${source_default.dim(String(v))}`);
+      }
+    }
+    if (t.dedup_key)
+      console.log(`
+  Dedup key:   ${t.dedup_key}`);
+    if (t.version)
+      console.log(`  Version:     ${t.version}`);
+    if (t.updated_at)
+      console.log(`  Updated:     ${t.updated_at}`);
+  },
+  extraListOptions: (cmd) => {
+    cmd.option("--active", "Only active triggers");
+  },
+  buildListParams: (opts) => {
+    const params = {};
+    if (opts.active)
+      params.active = "true";
+    return params;
+  },
+  extraCommands: (parentCmd, getCtx, isJson) => {
+    parentCmd.command("test <name>").description("Dry-run a trigger against a sample event (no workflow started)").requiredOption("--event <json>", "Sample CloudEvent JSON to match against").action(async (name, opts) => {
+      let event;
+      try {
+        event = JSON.parse(opts.event);
+      } catch {
+        throw new CLIError("--event must be valid JSON", 4 /* Validation */, `Example: martha triggers test ${name} --event '{"type":"facility_booking.booking.created","data":{}}'`);
+      }
+      const ctx = getCtx();
+      const res = await ctx.api.post(`/api/admin/triggers/${encodeURIComponent(name)}/test`, { event });
+      if (isJson()) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      console.log(res.matched ? source_default.green(`✓ trigger '${name}' WOULD fire for this event`) : source_default.yellow(`✗ trigger '${name}' would NOT fire for this event`));
+      console.log(`  Event-type / filter match: ${res.filter_result ? source_default.green("yes") : source_default.red("no")}`);
+      if (res.input_mapping_result) {
+        console.log(`
+  ${source_default.bold("Resolved input mapping:")}`);
+        for (const [k, v] of Object.entries(res.input_mapping_result)) {
+          console.log(`    ${k.padEnd(20)} ${source_default.dim(JSON.stringify(v))}`);
+        }
+      }
+    });
+  }
+};
+
 // src/commands/documents.ts
-import fs7 from "node:fs";
+import fs9 from "node:fs";
 init_errors();
 var TERMINAL_STATUSES2 = new Set(["ready", "error"]);
 var SPINNER_FRAMES2 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -13998,7 +14896,7 @@ function nextSpinner() {
   return frame;
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function formatBytes(bytes) {
   if (bytes < 1024)
@@ -14289,7 +15187,7 @@ ${items.length} collections`));
   });
   cmd.command("upload <collection-id> <file>").description("Upload a document to a collection").option("--wait", "Wait for ingestion to complete").option("--follow", "Follow ingestion progress in real time").action(async (collectionId, filePath, opts) => {
     const ctx = getCtx();
-    if (!fs7.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       throw new CLIError(`File not found: ${filePath}`, 4 /* Validation */);
     }
     const result = await ctx.api.upload(`/api/admin/collections/${encodeURIComponent(collectionId)}/documents`, filePath);
@@ -14921,18 +15819,18 @@ function registerApprovalCommands(program2) {
 import { readFileSync } from "node:fs";
 init_errors();
 var truncate2 = (s, n) => s.length > n ? s.slice(0, n - 1) + "…" : s;
-var sleep3 = (ms, signal) => new Promise((resolve) => {
+var sleep3 = (ms, signal) => new Promise((resolve2) => {
   if (signal?.aborted) {
-    resolve();
+    resolve2();
     return;
   }
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
-    resolve();
+    resolve2();
   }, ms);
   const onAbort = () => {
     clearTimeout(t);
-    resolve();
+    resolve2();
   };
   signal?.addEventListener("abort", onAbort, { once: true });
 });
@@ -15866,8 +16764,8 @@ ${data.length} spec(s)`));
 Resources:
 `));
       for (const r of resources) {
-        const path5 = r.path || `/${r.name}`;
-        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path5}`));
+        const path7 = r.path || `/${r.name}`;
+        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path7}`));
       }
     }
     try {
@@ -15887,14 +16785,14 @@ Functions:
     console.log(source_default.dim(`
 Proxy: martha integrations proxy ${name} GET /<path>`));
   });
-  cmd.command("proxy <name> <method> <path>").description("Send a request through the plugin proxy").option("--data <json>", "JSON request body").option("--query <params>", "Query params as key=val&key=val").action(async (name, method, path5, opts) => {
+  cmd.command("proxy <name> <method> <path>").description("Send a request through the plugin proxy").option("--data <json>", "JSON request body").option("--query <params>", "Query params as key=val&key=val").action(async (name, method, path7, opts) => {
     const ctx = getCtx();
     const upperMethod = method.toUpperCase();
     const allowed = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
     if (!allowed.has(upperMethod)) {
       throw new CLIError(`Invalid method: ${method}`, 4 /* Validation */, "Allowed: GET, POST, PUT, PATCH, DELETE");
     }
-    const cleanPath = path5.startsWith("/") ? path5.slice(1) : path5;
+    const cleanPath = path7.startsWith("/") ? path7.slice(1) : path7;
     const proxyUrl = `/api/admin/plugins/${encodeURIComponent(name)}/${cleanPath}`;
     const params = {};
     if (opts.query) {
@@ -16104,8 +17002,8 @@ async function resolveCredentialValue(value) {
   if (value === "-")
     return readStdin();
   if (value.startsWith("@")) {
-    const fs8 = await import("node:fs/promises");
-    return (await fs8.readFile(value.slice(1), "utf-8")).trim();
+    const fs10 = await import("node:fs/promises");
+    return (await fs10.readFile(value.slice(1), "utf-8")).trim();
   }
   return value;
 }
@@ -16220,8 +17118,8 @@ Notification connections`));
     if (credentialValue === "-") {
       credentialValue = await readStdin2();
     } else if (credentialValue?.startsWith("@")) {
-      const fs8 = await import("node:fs/promises");
-      credentialValue = await fs8.readFile(credentialValue.slice(1), "utf-8");
+      const fs10 = await import("node:fs/promises");
+      credentialValue = await fs10.readFile(credentialValue.slice(1), "utf-8");
     }
     if (!credentialValue) {
       throw new Error("--credential-value is required (use '-' for stdin or '@path' for file).");
@@ -16271,11 +17169,11 @@ async function readStdin2() {
 
 // src/commands/messaging.ts
 init_errors();
-async function messagingFetch(baseUrl, path5, opts) {
-  if (/^(https?:)?\/\//i.test(path5)) {
+async function messagingFetch(baseUrl, path7, opts) {
+  if (/^(https?:)?\/\//i.test(path7)) {
     throw new CLIError("Absolute URL paths are not allowed", 1 /* Error */);
   }
-  const url = new URL(path5, baseUrl);
+  const url = new URL(path7, baseUrl);
   const headers = {
     "Content-Type": "application/json"
   };
@@ -17555,7 +18453,7 @@ ${models.length} models`));
 }
 
 // src/commands/wiki.ts
-import fs8 from "node:fs";
+import fs10 from "node:fs";
 init_errors();
 function registerWikiCommands(program2) {
   const cmd = program2.command("wiki").description("Manage tenant wiki pages, settings, schema, recompile (#245 D5.4)");
@@ -17602,14 +18500,14 @@ function registerWikiCommands(program2) {
     console.log(source_default.dim(`
 ${pages.length} pages`));
   });
-  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--out <file>", "Write body to file instead of stdout").action(async (path5, opts) => {
+  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--out <file>", "Write body to file instead of stdout").action(async (path7, opts) => {
     const ctx = getCtx();
-    const safe = path5.split("/").map(encodeURIComponent).join("/");
+    const safe = path7.split("/").map(encodeURIComponent).join("/");
     const resp = await ctx.api.getRaw(`/api/wiki/pages/${safe}`, {
       headers: { Accept: "text/markdown,*/*" }
     });
     if (resp.status === 404) {
-      throw new CLIError(`page not found: ${path5}`, 3 /* NotFound */);
+      throw new CLIError(`page not found: ${path7}`, 3 /* NotFound */);
     }
     if (!resp.ok) {
       const detail = await resp.text();
@@ -17617,16 +18515,16 @@ ${pages.length} pages`));
     }
     const body = await resp.text();
     if (opts.out) {
-      fs8.writeFileSync(opts.out, body);
+      fs10.writeFileSync(opts.out, body);
       if (!isJson()) {
         console.log(source_default.dim(`wrote ${body.length} bytes to ${opts.out}`));
       } else {
-        console.log(JSON.stringify({ path: path5, bytes: body.length, file: opts.out }));
+        console.log(JSON.stringify({ path: path7, bytes: body.length, file: opts.out }));
       }
       return;
     }
     if (isJson()) {
-      console.log(JSON.stringify({ path: path5, body, etag: resp.headers.get("ETag") }));
+      console.log(JSON.stringify({ path: path7, body, etag: resp.headers.get("ETag") }));
     } else {
       process.stdout.write(body);
     }
@@ -17721,10 +18619,10 @@ ${pages.length} pages`));
     }
     if (opts.compilePromptOverrideFile) {
       const file = String(opts.compilePromptOverrideFile);
-      if (!fs8.existsSync(file)) {
+      if (!fs10.existsSync(file)) {
         throw new CLIError(`override file not found: ${file}`, 3 /* NotFound */);
       }
-      const content = fs8.readFileSync(file, "utf8");
+      const content = fs10.readFileSync(file, "utf8");
       const bytes = Buffer.byteLength(content, "utf8");
       if (bytes > 16 * 1024) {
         throw new CLIError(`compile prompt override exceeds 16 KB (${bytes} bytes)`, 4 /* Validation */);
@@ -17748,7 +18646,7 @@ ${pages.length} pages`));
     const ctx = getCtx();
     const resp = await ctx.api.get("/api/wiki/schema");
     if (opts.out) {
-      fs8.writeFileSync(opts.out, resp.body);
+      fs10.writeFileSync(opts.out, resp.body);
       if (!isJson()) {
         console.log(source_default.dim(`wrote ${resp.body.length} bytes to ${opts.out}`));
       } else {
@@ -17764,10 +18662,10 @@ ${pages.length} pages`));
   });
   schemaCmd.command("set").description("Replace the tenant wiki schema with the contents of <file>").requiredOption("--file <file>", "Path to schema markdown file").action(async (opts) => {
     const ctx = getCtx();
-    if (!fs8.existsSync(opts.file)) {
+    if (!fs10.existsSync(opts.file)) {
       throw new CLIError(`schema file not found: ${opts.file}`, 3 /* NotFound */);
     }
-    const body = fs8.readFileSync(opts.file, "utf8");
+    const body = fs10.readFileSync(opts.file, "utf8");
     const bytes = Buffer.byteLength(body, "utf8");
     if (bytes > 64 * 1024) {
       throw new CLIError(`schema body exceeds 64 KB (${bytes} bytes)`, 4 /* Validation */);
@@ -18103,7 +19001,7 @@ async function pollConnectionActive(ctx, connectionId) {
     });
     if (conn?.status === "active")
       return;
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   throw new CLIError(`Timed out waiting for OAuth authorization (${Math.round(timeoutMs / 1000)}s).`, 1 /* Error */, "The browser consent may not have completed. Re-run to try again, or check " + "the connection status in the admin UI.");
 }
@@ -18165,7 +19063,7 @@ async function pollExecution(ctx, executionId, timeoutMs) {
     if (["completed", "failed", "cancelled", "timeout"].includes(last.status)) {
       return last;
     }
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
   }
   throw new CLIError(`Timed out waiting for MCP workflow execution ${executionId}`, 1 /* Error */, last ? `Last status: ${last.status}` : undefined);
 }
@@ -18293,8 +19191,8 @@ async function resolveCredentialFlag(value) {
     return Buffer.concat(chunks).toString("utf-8").trim();
   }
   if (value.startsWith("@")) {
-    const fs9 = await import("node:fs/promises");
-    return (await fs9.readFile(value.slice(1), "utf-8")).trim();
+    const fs11 = await import("node:fs/promises");
+    return (await fs11.readFile(value.slice(1), "utf-8")).trim();
   }
   return value;
 }
@@ -19480,19 +20378,19 @@ function registerDoctorCommand(program2) {
 
 // src/commands/skill.ts
 init_errors();
-import fs9 from "node:fs";
-import path5 from "node:path";
+import fs11 from "node:fs";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 function locateSkill() {
-  const here = path5.dirname(fileURLToPath(import.meta.url));
+  const here = path7.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path5.join(here, "skills", "martha-cli", "SKILL.md"),
-    path5.join(here, "..", "skills", "martha-cli", "SKILL.md"),
-    path5.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
-    path5.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
+    path7.join(here, "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
   ];
   for (const p of candidates) {
-    if (fs9.existsSync(p))
+    if (fs11.existsSync(p))
       return p;
   }
   return null;
@@ -19502,7 +20400,7 @@ async function skillCommand() {
   if (!skillPath) {
     throw new CLIError("SKILL.md not found in the installed package. Reinstall via `npm i -g @aiaiai-pt/martha-cli` or `npx -y @aiaiai-pt/martha-cli@latest skill`.", 1 /* Error */);
   }
-  const body = fs9.readFileSync(skillPath, "utf-8");
+  const body = fs11.readFileSync(skillPath, "utf-8");
   process.stdout.write(body);
 }
 function registerSkillCommand(program2) {
@@ -19687,6 +20585,7 @@ registerConfigCommand(program2);
 registerDefinitionCommands(program2, functionsConfig);
 registerDefinitionCommands(program2, workflowsConfig);
 registerDefinitionCommands(program2, agentsConfig);
+registerDefinitionCommands(program2, triggersConfig);
 registerDefinitionsApply(program2);
 registerDefinitionsExport(program2);
 registerDocumentCommands(program2);