@zooid/core 0.12.0 → 0.14.0

package/dist/index.d.ts

@@ -7,7 +7,8 @@ import { EventEmitter } from 'node:events';
  * Per-agent ACP block in zooid.yaml. XOR: either a known preset or an
  * explicit command. The schema parser rejects both/neither.
  *
- * Built-in presets: `claude`, `codex`, `opencode`, `cline`, `kiro`, `gemini`.
+ * Built-in presets: `claude`, `codex`, `opencode`, `pi`, `cline`, `kiro`,
+ * `gemini`.
  * See `@zooid/acp-client`'s preset registry for the current list.
  */
 type AcpAgentSpec = {
@@ -318,12 +319,74 @@ interface ZooidConfig {
         pre_turn?: string;
         post_turn?: string;
     };
+    /** Optional. Map of trigger name → trigger. Empty map when the block is absent. */
+    triggers: Record<string, TriggerConfig>;
 }
 interface CliFlags {
     runtime?: string;
     /** Container image override (shorthand for container.image). */
     image?: string;
 }
+/**
+ * A webhook trigger: exposes `POST /_zooid/webhooks/<name>`, verifies an HMAC
+ * signature over the raw request body, and fires like a schedule trigger
+ * once accepted. See [[ZOD082]] §Design 4 and [[ZOD086]].
+ */
+interface WebhookTriggerConfig {
+    provider: 'github' | 'stripe' | 'slack' | 'standard' | 'custom';
+    /** Required. Interpolated from env — see [[ZOD081]] §Design 4, Secrets. */
+    secret: string;
+    /**
+     * `custom` only, required: path to a module exporting the verifier
+     * function, resolved to an absolute path against the zooid.yaml directory
+     * at parse time. The escape hatch for any scheme without a named provider
+     * — ed25519, SHA-1 over sorted params, bespoke timestamped base strings.
+     * Code rather than declarative fields, because a config language for
+     * signing schemes is a security-critical mini-DSL that still would not
+     * cover them all. The daemon imports it at startup — see
+     * `loadCustomVerifiers` in the CLI.
+     */
+    verify?: string;
+}
+/**
+ * One message a trigger can post: a room, the agent to mention, the body
+ * template, and — webhook triggers only — a CEL `match:` predicate gating
+ * whether this message fires for a given delivery. See [[ZOD085]] §Design 4.
+ */
+interface TriggerMessage {
+    /** Room id or alias the message goes to. */
+    room: string;
+    /** Agent name (key in `agents`) to mention. Structural, never templated — §Design 3. */
+    mention: string;
+    /** The message body. Literal for a scheduled trigger; `${...}` is CEL-interpolated for a webhook trigger. */
+    text: string;
+    /**
+     * CEL predicate over the delivery (`event`, `body`, `headers`, `output`).
+     * Absent means always fire. Only valid on a `webhook:` trigger — a
+     * schedule trigger has no delivery to evaluate.
+     */
+    match?: string;
+}
+/**
+ * A trigger: fires on a cron or a webhook delivery and posts one or more
+ * `messages`, each structurally mentioning its agent so the turn starts
+ * through the ordinary message path. No emitter/command tier — see
+ * [[ZOD081]] §Concept.
+ */
+interface TriggerConfig {
+    /** Cron expression. Mutually exclusive with `webhook:` — exactly one is required. */
+    schedule?: string;
+    /** Webhook ingress config. Mutually exclusive with `schedule:` — [[ZOD082]]. */
+    webhook?: WebhookTriggerConfig;
+    /** Full MXID the trigger posts as, e.g. `@cron:example.org`. */
+    as: string;
+    /**
+     * The messages this trigger can post. A flat `room:`/`mention:`/`text:`/
+     * `match:` at the trigger level desugars into a single-entry list here at
+     * config load — nothing downstream branches on which spelling was used.
+     */
+    messages: TriggerMessage[];
+}
 
 interface LoadZooidConfigOptions {
     /**
@@ -333,6 +396,13 @@ interface LoadZooidConfigOptions {
      * path.
      */
     configDir?: string;
+    /**
+     * Cron-expression validator, called as `validateCron(name, expr)` and
+     * expected to throw on an invalid expression. `core` takes no cron
+     * dependency — `cli` passes croner's parser at load time. Defaults to a
+     * field-count check sufficient to catch malformed input at parse time.
+     */
+    validateCron?: (name: string, expr: string) => void;
 }
 declare function loadZooidConfig(yamlText: string, opts?: LoadZooidConfigOptions): ZooidConfig;
 declare function findTransport(cfg: ZooidConfig, name: string): TransportConfig | undefined;
@@ -350,6 +420,42 @@ interface FoundConfigFile {
 declare function findConfigFile(cwd: string): FoundConfigFile | null;
 declare function mergeCliFlags(base: ZooidConfig, flags: CliFlags): ZooidConfig;
 
+interface MatchContext {
+    event: string | undefined;
+    body: unknown;
+    headers: Record<string, string>;
+    output: string;
+}
+/** Parse-check an expression. Throws on a syntax error, so a typo fails at config load. */
+declare function compileMatch(expr: string): string;
+/**
+ * Only an actual `true` fires. Everything else is "no match":
+ * - a CelError value (missing field, undeclared variable) — the library
+ *   returns these rather than throwing, and a merged-PR filter legitimately
+ *   errors on every issues delivery;
+ * - a truthy non-boolean (a string, a number), which must never be coerced;
+ * - a throw.
+ * Failing closed matters more here than anywhere else in the ingress: this is
+ * the only place an operator's typo could otherwise open a filter.
+ */
+declare function evaluateMatch(expr: string, ctx: MatchContext): boolean;
+
+/**
+ * Fill `${...}` placeholders in a trigger's `text:`. Each placeholder is a
+ * CEL expression over the same bindings `match:` sees — one expression
+ * language, not two. `${output}` is not a special case: `output` is just
+ * another bound variable, so a whole-payload dump still works for senders we
+ * control ([[ZOD081]] §2).
+ *
+ * An unresolvable placeholder (missing field, bad expression) renders as
+ * empty rather than throwing or pasting an error object into a room — a bad
+ * placeholder must not take the message down.
+ *
+ * The result is never re-scanned, so a payload that itself contains the
+ * literal string `${...}` cannot inject a placeholder.
+ */
+declare function renderTemplate(template: string, ctx: MatchContext): string;
+
 interface RegisteredApproval {
     approvalId: string;
     agentName: string;
@@ -469,8 +575,14 @@ interface AcpAgentRegistryOptions {
      * when the workspace mount is active; falls back to `agent.workdir`.
      */
     cwd?: Record<string, string>;
+    /**
+     * Called after an ACP session is created or recovered.  Context adapters
+     * which cannot receive an MCP spawn id (Pi) use this to resolve their
+     * daemon-side binding by the ACP session id instead.
+     */
+    onSessionEstablished?: (agentName: string, sessionKey: string, sessionId: string) => void;
 }
-type ContextSpawnFactory = (threadId: string, channelId?: string) => Promise<{
+type ContextSpawnFactory = (threadId: string, channelId?: string, sessionKey?: string) => Promise<{
     name: 'zooid-context';
     command: string;
     args: string[];
@@ -531,11 +643,21 @@ interface Member {
     is_agent: boolean;
     agent_name?: string;
 }
-interface ChannelInfo {
+/** Renamed from ChannelInfo — "channel" is not a Matrix primitive ([[ZOD084]]). */
+interface RoomInfo {
     id: string;
     name: string;
     transport: 'http' | 'matrix';
 }
+interface SendMessageInput {
+    room: string;
+    thread_id?: string;
+    text: string;
+}
+interface SendMessageResult {
+    event_id: string;
+    thread_id?: string;
+}
 interface HistoryPage {
     messages: Message[];
     next_before?: string;
@@ -583,7 +705,102 @@ interface TransportContextProvider {
     getRecentThreads(channelId: string, opts: HistoryOptions): Promise<ThreadOverviewPage>;
     getThreadHistory(channelId: string, threadId: string, opts: HistoryOptions): Promise<HistoryPage>;
     getChannelMembers(channelId: string): Promise<Member[]>;
-    getChannelInfo(channelId: string): Promise<ChannelInfo>;
+    /** Renamed from getChannelInfo. */
+    getRoomInfo(channelId: string): Promise<RoomInfo>;
+    /** Rooms this agent is bound to. Targets for sendMessage. */
+    getRooms(): Promise<RoomInfo[]>;
+    sendMessage(input: SendMessageInput): Promise<SendMessageResult>;
+}
+
+/** Harness-independent delegated-task contracts ([[ZOD072]]). */
+interface TaskCallerRef {
+    agentName: string;
+    channelId: string;
+    threadRoot: string;
+    sessionKey: string;
+}
+interface StartTaskSpec {
+    agent: string;
+    prompt: string;
+}
+interface StartTasksInput {
+    tasks: StartTaskSpec[];
+    notify?: 'caller' | 'none';
+}
+type StartTaskResult = {
+    agent: string;
+    status: 'started';
+    thread_id: string;
+} | {
+    agent: string;
+    status: 'refused' | 'failed';
+    reason: string;
+    attempt_id?: string;
+};
+interface StartTasksOutput {
+    results: StartTaskResult[];
+    notify: 'caller' | 'none';
+    /** Stated at the point of decision, where the model actually reads it. */
+    delivery: string;
+}
+interface CompleteTaskInput {
+    summary: string;
+}
+interface CompleteTaskOutput {
+    status: 'recorded' | 'already_recorded' | 'refused';
+    reason?: string;
+}
+/** What this session is, so the surface can gate itself instead of refusing later. */
+interface TaskRole {
+    is_task_assignee: boolean;
+    can_start_task_threads: boolean;
+}
+interface TaskActions {
+    startTasks(caller: TaskCallerRef, input: StartTasksInput): Promise<StartTasksOutput>;
+    completeTask(caller: TaskCallerRef, input: CompleteTaskInput): Promise<CompleteTaskOutput>;
+    describeRole(caller: TaskCallerRef): Promise<TaskRole>;
+}
+/** One in-thread handoff inside a delegated task. */
+type InvocationState = 'outstanding' | 'returned' | 'cancelled';
+interface InvocationRecord {
+    invocationId: string;
+    taskId: string;
+    callerAgent: string;
+    callerSessionKey: string;
+    calleeAgent: string;
+    callEventId?: string;
+    calleeSessionKey?: string;
+    state: InvocationState;
+}
+/** Open human-input requests for a session. ZOD078 supplies the implementation. */
+interface PendingInputRegistry {
+    countFor(sessionKey: string): number;
+    cancelFor(sessionKeys: string[]): void;
+}
+declare const NO_PENDING_INPUT: PendingInputRegistry;
+declare const THREAD_START_FIELD = "dev.zooid.thread_start";
+declare const THREAD_RESULT_FIELD = "dev.zooid.thread_result";
+interface ThreadStartContent {
+    version: 1;
+    assignee: string;
+    attempt_id: string;
+    parent: {
+        agent: string;
+        thread_root: string;
+        session_key: string;
+    };
+    notify: 'caller' | 'none';
+}
+interface ThreadCompletion {
+    agent: string;
+    thread_id: string;
+    status: 'complete' | 'failed' | 'cancelled' | 'partial';
+    output?: {
+        type: 'message';
+        text: string;
+    };
+    reason?: string;
+    error?: string;
 }
 
-export { AcpAgentRegistry, type AcpAgentRegistryOptions, type AcpAgentSpec, type AcpMount, type AcpRegistry, type AcpRegistryApprovalHandler, type AcpRegistryEventHandler, type AcpRuntime, type AcpSpawnSpec, type AgentConfig, ApprovalCorrelator, type ChannelInfo, type CliFlags, type ContainerConfig, type ContextSpawnFactory, type HistoryOptions, type HistoryPage, type HttpBinding, type HttpTransportConfig, type InboundMessage, type LoadZooidConfigOptions, type MatrixBinding, type MatrixTransportConfig, type Member, type Message, type MountConfig, type RegisterOptions, type RegisteredApproval, type RoomBinding, type ThreadOverview, type ThreadOverviewPage, type ThreadRef, type Transport, type TransportConfig, type TransportContextProvider, type ZooidConfig, type ZooidContainerConfig, findConfigFile, findHttpTransport, findMatrixTransport, findTransport, loadZooidConfig, mergeCliFlags, resolveAcpAgentSpec };
+export { AcpAgentRegistry, type AcpAgentRegistryOptions, type AcpAgentSpec, type AcpMount, type AcpRegistry, type AcpRegistryApprovalHandler, type AcpRegistryEventHandler, type AcpRuntime, type AcpSpawnSpec, type AgentConfig, ApprovalCorrelator, type CliFlags, type CompleteTaskInput, type CompleteTaskOutput, type ContainerConfig, type ContextSpawnFactory, type HistoryOptions, type HistoryPage, type HttpBinding, type HttpTransportConfig, type InboundMessage, type InvocationRecord, type InvocationState, type LoadZooidConfigOptions, type MatchContext, type MatrixBinding, type MatrixTransportConfig, type Member, type Message, type MountConfig, NO_PENDING_INPUT, type PendingInputRegistry, type RegisterOptions, type RegisteredApproval, type RoomBinding, type RoomInfo, type SendMessageInput, type SendMessageResult, type StartTaskResult, type StartTaskSpec, type StartTasksInput, type StartTasksOutput, THREAD_RESULT_FIELD, THREAD_START_FIELD, type TaskActions, type TaskCallerRef, type TaskRole, type ThreadCompletion, type ThreadOverview, type ThreadOverviewPage, type ThreadRef, type ThreadStartContent, type Transport, type TransportConfig, type TransportContextProvider, type TriggerConfig, type TriggerMessage, type WebhookTriggerConfig, type ZooidConfig, type ZooidContainerConfig, compileMatch, evaluateMatch, findConfigFile, findHttpTransport, findMatrixTransport, findTransport, loadZooidConfig, mergeCliFlags, renderTemplate, resolveAcpAgentSpec };

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/config.ts
 import { existsSync } from "fs";
 import { isAbsolute, join, resolve as pathResolve } from "path";
-import { parse } from "yaml";
+import { parse as parse2 } from "yaml";
 import { isPreset } from "@zooid/acp-client";
 
 // src/env-interpolation.ts
@@ -54,7 +54,23 @@ function interpolateString(value, processEnv) {
   return result.parsed?.[sentinel] ?? "";
 }
 
+// src/match-expression.ts
+import { parse, run } from "@bufbuild/cel";
+function compileMatch(expr) {
+  parse(expr);
+  return expr;
+}
+function evaluateMatch(expr, ctx) {
+  try {
+    const result = run(expr, { ...ctx });
+    return result === true;
+  } catch {
+    return false;
+  }
+}
+
 // src/config.ts
+var WEBHOOK_PROVIDERS = ["github", "stripe", "slack", "standard", "custom"];
 var SLUG_RE = /^[a-z0-9-]+$/;
 var AGENT_NAME_RE = /^[a-z][a-z0-9-]{0,31}$/;
 var MATRIX_USER_ID_RE = /^@[A-Za-z0-9._\-=/+]+:[A-Za-z0-9.\-]+$/;
@@ -707,6 +723,203 @@ See [ZOD043].`
   }
   return result;
 }
+function defaultValidateCron(name, expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length < 5 || parts.length > 7) {
+    throw new Error(
+      `triggers.${name}.schedule: invalid cron expression ${JSON.stringify(expr)}`
+    );
+  }
+}
+function expandTriggerAs(name, as, transports) {
+  if (as.includes(":")) {
+    if (!MATRIX_USER_ID_RE.test(as)) {
+      throw new Error(`triggers.${name}.as: must be a full MXID (got ${JSON.stringify(as)})`);
+    }
+    return as;
+  }
+  const bare = as.startsWith("@") ? as : `@${as}`;
+  if (!MATRIX_USER_LOCALPART_RE.test(bare)) {
+    throw new Error(`triggers.${name}.as: must be a full MXID (got ${JSON.stringify(as)})`);
+  }
+  const matrixTransports = Object.values(transports).filter(
+    (t) => t.type === "matrix"
+  );
+  if (matrixTransports.length !== 1) {
+    throw new Error(
+      `triggers.${name}.as: "${as}" is a bare localpart, which requires exactly one matrix transport to expand against (found ${matrixTransports.length}). Use a full MXID instead.`
+    );
+  }
+  const serverName = deriveServerName(matrixTransports[0].user_namespace);
+  return `${bare}:${serverName}`;
+}
+function parseTriggers(raw, agents, transports, validateCron, processEnv, configDir) {
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("triggers: must be a mapping");
+  }
+  const result = {};
+  for (const [name, val] of Object.entries(raw)) {
+    if (!val || typeof val !== "object" || Array.isArray(val)) {
+      throw new Error(`triggers.${name} must be a mapping`);
+    }
+    const t = val;
+    if (t.run !== void 0) {
+      throw new Error(
+        `triggers.${name}.run: is not supported \u2014 a trigger posts a message and the agent runs what needs running. See [ZOD081] \xA7Concept.`
+      );
+    }
+    if (t.schedule === void 0 && t.webhook === void 0) {
+      throw new Error(`triggers.${name}: must specify schedule: or webhook:`);
+    }
+    if (t.schedule !== void 0 && t.webhook !== void 0) {
+      throw new Error(`triggers.${name}: specify either schedule: or webhook:, not both`);
+    }
+    let schedule;
+    if (t.schedule !== void 0) {
+      if (typeof t.schedule !== "string" || t.schedule.length === 0) {
+        throw new Error(`triggers.${name}.schedule: must be a non-empty string`);
+      }
+      validateCron(name, t.schedule);
+      schedule = t.schedule;
+    }
+    let webhook;
+    if (t.webhook !== void 0) {
+      webhook = parseWebhookTrigger(name, t.webhook, processEnv, configDir);
+    }
+    if (typeof t.as !== "string" || t.as.length === 0) {
+      throw new Error(`triggers.${name}.as: must be a non-empty string`);
+    }
+    const as = expandTriggerAs(name, t.as, transports);
+    const hasFlat = t.room !== void 0 || t.mention !== void 0 || t.text !== void 0 || t.match !== void 0;
+    const hasMessages = t.messages !== void 0;
+    if (hasFlat && hasMessages) {
+      throw new Error(
+        `triggers.${name}: specify either room:/mention:/text: or messages:, not both`
+      );
+    }
+    if (!hasFlat && !hasMessages) {
+      throw new Error(`triggers.${name}: must specify room:/mention:/text: or messages:`);
+    }
+    let rawMessages;
+    if (hasFlat) {
+      if (t.match !== void 0 && !webhook) {
+        throw new Error(`triggers.${name}.match: only applies to a webhook: trigger`);
+      }
+      rawMessages = [{ room: t.room, mention: t.mention, text: t.text, match: t.match }];
+    } else {
+      if (!Array.isArray(t.messages)) {
+        throw new Error(`triggers.${name}.messages: must be a list`);
+      }
+      if (t.messages.length === 0) {
+        throw new Error(`triggers.${name}.messages: must not be empty`);
+      }
+      rawMessages = t.messages;
+    }
+    const messages = rawMessages.map(
+      (m, i) => parseTriggerMessage(name, i, m, agents, as, !!webhook)
+    );
+    const entry = { as, messages };
+    if (schedule !== void 0) entry.schedule = schedule;
+    if (webhook !== void 0) entry.webhook = webhook;
+    result[name] = entry;
+  }
+  return result;
+}
+function parseTriggerMessage(name, index, raw, agents, as, hasWebhook) {
+  const label = `triggers.${name}.messages[${index}]`;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${label}: must be a mapping`);
+  }
+  const m = raw;
+  if (typeof m.room !== "string" || m.room.length === 0) {
+    throw new Error(`${label}.room: must be a non-empty string`);
+  }
+  if (!MATRIX_ROOM_IDENT_RE.test(m.room)) {
+    throw new Error(`${label}.room: must start with '#' or '!' (got ${JSON.stringify(m.room)})`);
+  }
+  if (typeof m.mention !== "string" || m.mention.length === 0) {
+    throw new Error(`${label}.mention: must be a non-empty string`);
+  }
+  const mentionedAgent = agents[m.mention];
+  if (!mentionedAgent) {
+    throw new Error(`${label}.mention: unknown agent "${m.mention}"`);
+  }
+  if (!mentionedAgent.matrix) {
+    throw new Error(
+      `${label}.mention: agent "${m.mention}" has no matrix: binding \u2014 a trigger posts through Matrix, so the mentioned agent must be matrix-bound.`
+    );
+  }
+  if (as === mentionedAgent.matrix.user_id) {
+    throw new Error(
+      `triggers.${name}.as: must not equal the mentioned agent's own MXID (${as}) \u2014 a message an agent sends never routes back to itself, so this trigger would silently never wake "${m.mention}". Post as a different identity (a dedicated bot, or another agent's).`
+    );
+  }
+  if (typeof m.text !== "string" || m.text.length === 0) {
+    throw new Error(`${label}.text: must be a non-empty string`);
+  }
+  const message = { room: m.room, mention: m.mention, text: m.text };
+  if (m.match !== void 0) {
+    if (typeof m.match !== "string" || m.match.length === 0) {
+      throw new Error(`${label}.match: must be a non-empty string`);
+    }
+    if (!hasWebhook) {
+      throw new Error(`${label}.match: only applies to a webhook: trigger`);
+    }
+    try {
+      message.match = compileMatch(m.match);
+    } catch (err) {
+      throw new Error(`${label}.match: ${err.message}`);
+    }
+  }
+  return message;
+}
+function parseWebhookTrigger(name, raw, processEnv, configDir) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`triggers.${name}.webhook: must be a mapping`);
+  }
+  const w = raw;
+  if (typeof w.provider !== "string" || w.provider.length === 0) {
+    throw new Error(`triggers.${name}.webhook.provider: must be a non-empty string`);
+  }
+  if (!WEBHOOK_PROVIDERS.includes(w.provider)) {
+    throw new Error(
+      `triggers.${name}.webhook.provider: unknown provider ${JSON.stringify(w.provider)} (expected one of: ${WEBHOOK_PROVIDERS.join(", ")})`
+    );
+  }
+  const provider = w.provider;
+  if (w.event !== void 0) {
+    throw new Error(`triggers.${name}.webhook.event: no longer supported \u2014 use match:`);
+  }
+  if (typeof w.secret !== "string" || w.secret.length === 0) {
+    throw new Error(`triggers.${name}.webhook.secret: is required`);
+  }
+  const secret = interpolateString(w.secret, processEnv);
+  const config = { provider, secret };
+  if (provider !== "custom") {
+    if (w.verify !== void 0) {
+      throw new Error(
+        `triggers.${name}.webhook.verify: only applies to provider: custom (this trigger uses provider: ${provider}, whose signing scheme is built in)`
+      );
+    }
+    return config;
+  }
+  if (typeof w.verify !== "string" || w.verify.length === 0) {
+    throw new Error(
+      `triggers.${name}.webhook.verify: is required when provider: custom (path to a module exporting the verifier function)`
+    );
+  }
+  if (isAbsolute(w.verify)) {
+    config.verify = w.verify;
+  } else if (!configDir) {
+    throw new Error(
+      `triggers.${name}.webhook.verify: relative path ${JSON.stringify(w.verify)} requires configDir (zooid.yaml directory) \u2014 pass it via loadZooidConfig(yaml, { configDir })`
+    );
+  } else {
+    config.verify = pathResolve(configDir, w.verify);
+  }
+  return config;
+}
 function parseRuntime(raw) {
   const runtime = raw ?? "docker";
   if (runtime !== "local" && runtime !== "docker" && runtime !== "podman") {
@@ -724,7 +937,7 @@ function zooidHooks(raw) {
   return out;
 }
 function loadZooidConfig(yamlText, opts = {}) {
-  const raw = parse(yamlText) ?? {};
+  const raw = parse2(yamlText) ?? {};
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new Error("zooid.yaml must be a YAML object");
   }
@@ -767,11 +980,20 @@ function loadZooidConfig(yamlText, opts = {}) {
   const transports = parseTransports(r.transports, processEnv, workstation);
   const hooks = zooidHooks(r);
   const agents = parseAgents(r.agents, runtime, transports, hooks, processEnv, opts.configDir);
+  const triggers = parseTriggers(
+    r.triggers,
+    agents,
+    transports,
+    opts.validateCron ?? defaultValidateCron,
+    processEnv,
+    opts.configDir
+  );
   const cfg = {
     runtime,
     transports,
     agents,
-    hooks
+    hooks,
+    triggers
   };
   if (workstation !== void 0) cfg.workstation = workstation;
   if (r.container !== void 0 && r.container !== null) {
@@ -834,7 +1056,8 @@ function mergeCliFlags(base, flags) {
     runtime,
     transports: base.transports,
     agents: base.agents,
-    hooks: { ...base.hooks }
+    hooks: { ...base.hooks },
+    triggers: base.triggers
   };
   if (runtime === "docker" || runtime === "podman") {
     const image = flags.image ?? base.container?.image;
@@ -847,6 +1070,22 @@ function mergeCliFlags(base, flags) {
   return merged;
 }
 
+// src/render-template.ts
+import { run as run2, isCelError } from "@bufbuild/cel";
+var PLACEHOLDER_RE = /\$\{([\s\S]+?)\}/g;
+function renderTemplate(template, ctx) {
+  return template.replace(PLACEHOLDER_RE, (_match, expr) => {
+    let result;
+    try {
+      result = run2(expr, { ...ctx });
+    } catch {
+      return "";
+    }
+    if (result === void 0 || isCelError(result)) return "";
+    return String(result);
+  });
+}
+
 // src/acp-registry.ts
 import { mkdirSync } from "fs";
 import { join as join2 } from "path";
@@ -906,7 +1145,9 @@ var AcpAgentRegistry = class {
   async ensureSession(name, threadId, channelId, contextThreadId) {
     if (!this.hasAgent(name)) throw new Error(`unknown agent: ${name}`);
     const client = await this.ensureClient(name);
-    return client.ensureSession(threadId, channelId, contextThreadId);
+    const sessionId = await client.ensureSession(threadId, channelId, contextThreadId);
+    this.opts.onSessionEstablished?.(name, threadId, sessionId);
+    return sessionId;
   }
   endSession(name, threadId) {
     if (!this.hasAgent(name)) return;
@@ -930,9 +1171,7 @@ var AcpAgentRegistry = class {
     return client.prompt(input);
   }
   async stopAll() {
-    await Promise.allSettled(
-      [...this.clients.values()].map((c) => c.stop())
-    );
+    await Promise.allSettled([...this.clients.values()].map((c) => c.stop()));
     this.clients.clear();
   }
   async ensureClient(name) {
@@ -1069,15 +1308,30 @@ var ApprovalCorrelator = class extends EventEmitter {
     };
   }
 };
+
+// src/task-actions.ts
+var NO_PENDING_INPUT = {
+  countFor: () => 0,
+  cancelFor: () => {
+  }
+};
+var THREAD_START_FIELD = "dev.zooid.thread_start";
+var THREAD_RESULT_FIELD = "dev.zooid.thread_result";
 export {
   AcpAgentRegistry,
   ApprovalCorrelator,
+  NO_PENDING_INPUT,
+  THREAD_RESULT_FIELD,
+  THREAD_START_FIELD,
+  compileMatch,
+  evaluateMatch,
   findConfigFile,
   findHttpTransport,
   findMatrixTransport,
   findTransport,
   loadZooidConfig,
   mergeCliFlags,
+  renderTemplate,
   resolveAcpAgentSpec
 };
 //# sourceMappingURL=index.js.map