agentix-cli 0.131.0 → 0.133.0

package/dist/index.d.ts

@@ -3114,7 +3114,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             /** How pages are picked (#855). `summaries`: from the one-line page
              *  summaries `agentx wiki summarize` writes, then a live read.
              *  `catalog`: from titles, then a walk along the pages' links.
-             *  `auto`: `summaries` once summaries exist, `catalog` until then. */
+             *  `auto`: `summaries` once most of the agent's own pages have a
+             *  summary (AUTO_SUMMARY_COVERAGE in src/wiki/query.ts), `catalog`
+             *  until then. */
             method: z.ZodDefault<z.ZodEnum<["auto", "summaries", "catalog"]>>;
             /** The agent's own pages shown to the model that picks. */
             candidates: z.ZodDefault<z.ZodNumber>;
@@ -3122,6 +3124,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             sharedCandidates: z.ZodDefault<z.ZodNumber>;
             /** Most pages opened for one answer. */
             maxPages: z.ZodDefault<z.ZodNumber>;
+            /** Pages also opened along the `related` links of the picked pages
+             *  (summaries method), in total. 0: none. */
+            linkedPages: z.ZodDefault<z.ZodNumber>;
             /** Characters of each opened page given to the answer. */
             pageChars: z.ZodDefault<z.ZodNumber>;
             /** Model that picks pages from the summary lines. */
@@ -3291,6 +3296,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
+            linkedPages: number;
             pageChars: number;
             navigatorModel: string;
             answerModel: string;
@@ -3329,6 +3335,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
+            linkedPages?: number | undefined;
             pageChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
@@ -3371,8 +3378,8 @@ declare const daemonConfigSchema: z.ZodObject<{
             maxWords: z.ZodDefault<z.ZodNumber>;
             /** When `agentx wiki summarize` runs on its own (cron, 5 fields).
              *  Unset: no job is added. */
-            schedule: z.ZodOptional<z.ZodString>;
-            timezone: z.ZodDefault<z.ZodString>;
+            schedule: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            timezone: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
             /** Agent the job is filed under. Unset: `node.defaultAgent`, else
              *  the first agent. */
             agent: z.ZodOptional<z.ZodString>;
@@ -3411,6 +3418,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
+            linkedPages: number;
             pageChars: number;
             navigatorModel: string;
             answerModel: string;
@@ -3470,6 +3478,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
+            linkedPages?: number | undefined;
             pageChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
@@ -5526,6 +5535,34 @@ declare const daemonConfigSchema: z.ZodObject<{
             windowMinutes?: number | undefined;
         } | undefined;
     }>>;
+    /** Stop and resume signals (agents/signals, #857): stop a running task
+     *  cleanly, keep the agent's resume plan, resume it later. The owner may
+     *  always signal; an agent may signal tasks it dispatched, or any task
+     *  when listed in allowAgents; a mesh peer only when listed in allowPeers. */
+    signals: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** How long the stopped agent gets to write its resume plan. Past it,
+         *  the wind-down is stopped and a plan is built from the trace. */
+        windDownSeconds: z.ZodDefault<z.ZodNumber>;
+        /** Agents that may stop or resume any agent's task here ("*" for all). */
+        allowAgents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Mesh peers (node names) whose stop and resume signals are accepted. */
+        allowPeers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Loop brake: most signals one root id may carry in a day. */
+        maxPerRoot: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        windDownSeconds: number;
+        allowAgents: string[];
+        allowPeers: string[];
+        maxPerRoot: number;
+    }, {
+        enabled?: boolean | undefined;
+        windDownSeconds?: number | undefined;
+        allowAgents?: string[] | undefined;
+        allowPeers?: string[] | undefined;
+        maxPerRoot?: number | undefined;
+    }>>;
     /** Open requests (src/requests, #356): what a person asked an agent for
      *  is recorded and followed until it is done, declined or dropped. Off
      *  by default. */
@@ -7346,6 +7383,26 @@ declare const daemonConfigSchema: z.ZodObject<{
             stallMinutes?: number | undefined;
             maxNudges?: number | undefined;
         }>>;
+        /** Run every task through a workflow (#858): a saved workflow that
+         *  fits, else a plan the agent writes first, else the one-step
+         *  `linear` template. Needs `enabled`. Off by default. */
+        required: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Per agent, by id: true or false wins over `enabled`. */
+            agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            /** A plain question answered in one turn, with no plan and only tools
+             *  that change nothing, leaves no run. On by default: such a turn has
+             *  nothing to follow up. */
+            exemptQuestions: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            exemptQuestions: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            exemptQuestions?: boolean | undefined;
+        }>>;
         /** Controls whether the dashboard exposes the visual editor. "readonly"
          *  serves the list + run timelines but strips write controls from the
          *  page. "disabled" hides the tab entirely. */
@@ -7353,6 +7410,11 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         dir: string;
         enabled: boolean;
+        required: {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            exemptQuestions: boolean;
+        };
         followUp: {
             enabled: boolean;
             agents: Record<string, boolean>;
@@ -7374,6 +7436,11 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        required?: {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            exemptQuestions?: boolean | undefined;
+        } | undefined;
         followUp?: {
             enabled?: boolean | undefined;
             agents?: Record<string, boolean> | undefined;
@@ -8030,6 +8097,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
+            linkedPages: number;
             pageChars: number;
             navigatorModel: string;
             answerModel: string;
@@ -8520,6 +8588,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         };
         drainTimeoutSeconds?: number | undefined;
     };
+    signals: {
+        enabled: boolean;
+        windDownSeconds: number;
+        allowAgents: string[];
+        allowPeers: string[];
+        maxPerRoot: number;
+    };
     people: {
         agents: string[];
         id: string;
@@ -8650,6 +8725,11 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows: {
         dir: string;
         enabled: boolean;
+        required: {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            exemptQuestions: boolean;
+        };
         followUp: {
             enabled: boolean;
             agents: Record<string, boolean>;
@@ -8973,6 +9053,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
+            linkedPages?: number | undefined;
             pageChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
@@ -9525,6 +9606,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         } | undefined;
         drainTimeoutSeconds?: number | undefined;
     } | undefined;
+    signals?: {
+        enabled?: boolean | undefined;
+        windDownSeconds?: number | undefined;
+        allowAgents?: string[] | undefined;
+        allowPeers?: string[] | undefined;
+        maxPerRoot?: number | undefined;
+    } | undefined;
     people?: {
         id: string;
         name: string;
@@ -9655,6 +9743,11 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows?: {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        required?: {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            exemptQuestions?: boolean | undefined;
+        } | undefined;
         followUp?: {
             enabled?: boolean | undefined;
             agents?: Record<string, boolean> | undefined;
@@ -10202,6 +10295,8 @@ interface AgentXEvents {
         /** A daemon shutdown stopped the run. Its trace stays in flight so the
          *  next boot can resume it. */
         interrupted?: boolean;
+        /** Ended by a stop signal (agents/signals, #857): status `stopped`. */
+        stopped?: boolean;
         inputTokens?: number;
         outputTokens?: number;
         cacheReadTokens?: number;
@@ -10435,6 +10530,8 @@ declare class AgentXDaemon {
     private landscape;
     private heartbeat;
     private stopEventWaker?;
+    /** Stop and resume signals (agents/signals, #857). */
+    private signals;
     private business?;
     private httpServer?;
     private attachSweep?;
@@ -10525,6 +10622,12 @@ declare class AgentXDaemon {
     private bootTimes;
     /** Every start on record with who stopped the one before (boot-record.ts). */
     private bootLog;
+    /** The resumers that re-enter a run where it came from: used by the boot
+     *  resume pass and by resume signals (agents/signals, #857). */
+    private resumeCoordinatorInstance?;
+    private resumeCoordinator;
+    /** Stop a running task with a resume plan, and resume it later (#857). */
+    private createSignalService;
     /** Resume, report or skip each run the last restart cut off. Never throws. */
     private resumeInterruptedRuns;
     /**
@@ -11024,7 +11127,9 @@ interface FriendlyError {
     /** Optional next step the user can take. */
     fix?: string;
     /** Machine-readable error category for routing / retries. */
-    kind: "out_of_credits" | "overage_disabled" | "usage_cap" | "auth" | "permission" | "rate_limit" | "overloaded" | "context_too_large" | "invalid_request" | "upstream_api" | "timeout" | "cancelled" | "interrupted" | "unknown";
+    kind: "out_of_credits" | "overage_disabled" | "usage_cap" | "auth" | "permission" | "rate_limit" | "overloaded" | "context_too_large" | "invalid_request" | "upstream_api" | "timeout" | "cancelled" | "interrupted"
+    /** Ended by a stop signal; its resume plan is saved (#857). */
+     | "stopped" | "unknown";
     /** Whether this error is transient — a retry has a reasonable chance of succeeding. */
     retryable: boolean;
     /** Source error text retained for logs / debugging. */
@@ -11119,10 +11224,12 @@ interface IncomingMessage {
     runbookFiles?: string[];
     /** Set when this message re-runs one a restart cut off (agents/resume):
      *  the note for the agent, the attempt number, and the run it continues. */
+    /** `rootId`: a task resumed after a stop signal keeps its root (#857). */
     resume?: {
         note: string;
         attempt: number;
         resumedFrom: string;
+        rootId?: string;
     };
 }
 interface OutgoingMessage {
@@ -13192,6 +13299,1271 @@ declare class LandscapeBuilder {
     private extractCapability;
 }
 
+declare const runStatusSchema: z.ZodEnum<["running", "paused", "completed", "failed", "canceled"]>;
+type RunStatus = z.infer<typeof runStatusSchema>;
+declare const nodeExecutionEntrySchema: z.ZodObject<{
+    at: z.ZodString;
+    nodeId: z.ZodString;
+    /** Which upstream node outputs fed this execution. Usually one id, or
+     *  empty for the trigger. */
+    inputKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodEnum<["ok", "failed", "timeout", "skipped", "paused", "resumed"]>;
+    /** The node's output bundle, if successful. Stored here so the full run
+     *  history can be replayed without the live context. */
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Per-(runId, nodeId, eventId) key used to drop duplicate webhook
+     *  deliveries when a run is resumed from a checkpoint. */
+    idempotencyKey: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    /** When the step began (#858). `at` is when it was recorded, so the
+     *  step took `durationMs` from here. Absent on entries written before. */
+    startedAt: z.ZodOptional<z.ZodString>;
+    /** How long the step ran, in milliseconds (#858). */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+    idempotencyKey: string;
+    nodeId: string;
+    inputKeys: string[];
+    output?: Record<string, unknown> | undefined;
+    durationMs?: number | undefined;
+    note?: string | undefined;
+    startedAt?: string | undefined;
+}, {
+    at: string;
+    status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+    idempotencyKey: string;
+    nodeId: string;
+    output?: Record<string, unknown> | undefined;
+    durationMs?: number | undefined;
+    note?: string | undefined;
+    startedAt?: string | undefined;
+    inputKeys?: string[] | undefined;
+}>;
+type NodeExecutionEntry = z.infer<typeof nodeExecutionEntrySchema>;
+declare const entityRefSchema: z.ZodObject<{
+    backend: z.ZodString;
+    /** Stable identifier for the entity this run is scoped to. Used to key
+     *  the entity index so webhook re-entry can find the active run. */
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    backend: string;
+}, {
+    id: string;
+    backend: string;
+}>;
+type EntityRef = z.infer<typeof entityRefSchema>;
+declare const pausedAtSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"checkpoint">;
+    nodeId: z.ZodString;
+    checkpointName: z.ZodString;
+    /** Filter applied to incoming events for resume. Same shape as the
+     *  matching trigger.channel filter. */
+    resumeMatch: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "checkpoint";
+    nodeId: string;
+    checkpointName: string;
+    resumeMatch: Record<string, unknown>;
+}, {
+    kind: "checkpoint";
+    nodeId: string;
+    checkpointName: string;
+    resumeMatch?: Record<string, unknown> | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"subProcess">;
+    nodeId: z.ZodString;
+    childRunId: z.ZodString;
+    childWorkflowId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "subProcess";
+    nodeId: string;
+    childRunId: string;
+    childWorkflowId: string;
+}, {
+    kind: "subProcess";
+    nodeId: string;
+    childRunId: string;
+    childWorkflowId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"signalWait">;
+    nodeId: z.ZodString;
+    signalName: z.ZodString;
+    /** Optional field-match filter against the emitted signal payload. */
+    match: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    scope: z.ZodDefault<z.ZodEnum<["workflow", "global"]>>;
+}, "strip", z.ZodTypeAny, {
+    match: Record<string, unknown>;
+    kind: "signalWait";
+    scope: "workflow" | "global";
+    nodeId: string;
+    signalName: string;
+}, {
+    kind: "signalWait";
+    nodeId: string;
+    signalName: string;
+    match?: Record<string, unknown> | undefined;
+    scope?: "workflow" | "global" | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"timerWait">;
+    nodeId: z.ZodString;
+    /** ISO-8601 instant when the timer should fire. */
+    fireAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "timerWait";
+    nodeId: string;
+    fireAt: string;
+}, {
+    kind: "timerWait";
+    nodeId: string;
+    fireAt: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"ownerDecision">;
+    nodeId: z.ZodString;
+    cardId: z.ZodString;
+    purpose: z.ZodEnum<["ask", "send", "start"]>;
+    message: z.ZodOptional<z.ZodObject<{
+        channel: z.ZodString;
+        chatId: z.ZodString;
+        accountId: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+        to: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        channel: string;
+        chatId: string;
+        to?: string | undefined;
+        accountId?: string | undefined;
+    }, {
+        text: string;
+        channel: string;
+        chatId: string;
+        to?: string | undefined;
+        accountId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "ownerDecision";
+    cardId: string;
+    nodeId: string;
+    purpose: "start" | "send" | "ask";
+    message?: {
+        text: string;
+        channel: string;
+        chatId: string;
+        to?: string | undefined;
+        accountId?: string | undefined;
+    } | undefined;
+}, {
+    kind: "ownerDecision";
+    cardId: string;
+    nodeId: string;
+    purpose: "start" | "send" | "ask";
+    message?: {
+        text: string;
+        channel: string;
+        chatId: string;
+        to?: string | undefined;
+        accountId?: string | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"replyWait">;
+    nodeId: z.ZodString;
+    channel: z.ZodString;
+    chatId: z.ZodString;
+    accountId: z.ZodOptional<z.ZodString>;
+    /** In a group: only this sender's message counts. */
+    from: z.ZodOptional<z.ZodString>;
+    deadline: z.ZodString;
+    nextRemindAt: z.ZodOptional<z.ZodString>;
+    remindEveryMs: z.ZodOptional<z.ZodNumber>;
+    reminders: z.ZodDefault<z.ZodNumber>;
+    maxReminders: z.ZodDefault<z.ZodNumber>;
+    /** A person.message step whose sent text the reminder repeats. Unset:
+     *  the reminder goes to the owner instead. */
+    reminds: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channel: string;
+    chatId: string;
+    kind: "replyWait";
+    reminders: number;
+    nodeId: string;
+    deadline: string;
+    maxReminders: number;
+    from?: string | undefined;
+    accountId?: string | undefined;
+    nextRemindAt?: string | undefined;
+    remindEveryMs?: number | undefined;
+    reminds?: string | undefined;
+}, {
+    channel: string;
+    chatId: string;
+    kind: "replyWait";
+    nodeId: string;
+    deadline: string;
+    from?: string | undefined;
+    accountId?: string | undefined;
+    reminders?: number | undefined;
+    nextRemindAt?: string | undefined;
+    remindEveryMs?: number | undefined;
+    maxReminders?: number | undefined;
+    reminds?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"agentStep">;
+    nodeId: z.ZodString;
+    agentId: z.ZodString;
+    nudges: z.ZodDefault<z.ZodNumber>;
+    maxNudges: z.ZodDefault<z.ZodNumber>;
+    stallMs: z.ZodNumber;
+    nextNudgeAt: z.ZodOptional<z.ZodString>;
+    /** Set once the step is blocked: no more nudges, the owner is told. */
+    blocked: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "agentStep";
+    agentId: string;
+    nudges: number;
+    maxNudges: number;
+    nodeId: string;
+    stallMs: number;
+    blocked?: string | undefined;
+    nextNudgeAt?: string | undefined;
+}, {
+    kind: "agentStep";
+    agentId: string;
+    nodeId: string;
+    stallMs: number;
+    blocked?: string | undefined;
+    nudges?: number | undefined;
+    maxNudges?: number | undefined;
+    nextNudgeAt?: string | undefined;
+}>]>;
+type PausedAt = z.infer<typeof pausedAtSchema>;
+/** What a follow-up run is about and who started it (#788). Runs that
+ *  triggers start have none. */
+declare const runMetaSchema: z.ZodObject<{
+    /** One line: what this run is doing, in the owner's words. */
+    title: z.ZodOptional<z.ZodString>;
+    /** What the run concerns, as "kind:name" (client:acme, employee:sam,
+     *  project:site, idea:newsletter). The progress view groups by these. */
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The agent that started it. */
+    startedBy: z.ZodOptional<z.ZodString>;
+    /** The open request (src/requests) this run serves. */
+    requestId: z.ZodOptional<z.ZodString>;
+    /** Followed: nudges, reminders, a blocked notice and one summary at
+     *  the end. */
+    followUp: z.ZodDefault<z.ZodBoolean>;
+    /** The owner approved this run's messages when it started. */
+    approvedAtStart: z.ZodDefault<z.ZodBoolean>;
+    /** The messages that approval covers, by step id: recipient and text as
+     *  the owner saw them (messageKey). Any other message is asked again. */
+    approved: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Why the run cannot go on without the owner, and when they were told. */
+    blocked: z.ZodOptional<z.ZodObject<{
+        nodeId: z.ZodString;
+        reason: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        reason: string;
+        nodeId: string;
+    }, {
+        at: string;
+        reason: string;
+        nodeId: string;
+    }>>;
+    /** The owner got the end summary. Sent once. */
+    endNotifiedAt: z.ZodOptional<z.ZodString>;
+    /** A task run inside a workflow because `workflows.required` is on
+     *  (#858): the agent turn it wraps. `mode` is `linear` (the one-step
+     *  template) until the agent writes a plan. */
+    wrap: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        channel: z.ZodString;
+        mode: z.ZodEnum<["linear", "plan"]>;
+        taskId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channel: string;
+        mode: "plan" | "linear";
+        agentId: string;
+        taskId?: string | undefined;
+    }, {
+        channel: string;
+        mode: "plan" | "linear";
+        agentId: string;
+        taskId?: string | undefined;
+    }>>;
+    /** The plan the agent wrote for a wrapped task, and each change to it. */
+    plan: z.ZodOptional<z.ZodObject<{
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            title: string;
+        }, {
+            id: string;
+            title: string;
+        }>, "many">;
+        /** The step the agent said it started, and when. */
+        current: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            startedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            startedAt: string;
+        }, {
+            id: string;
+            startedAt: string;
+        }>>;
+        revisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            /** `plan`: the first plan. `revise`: a change to the steps left. */
+            kind: z.ZodEnum<["plan", "revise"]>;
+            reason: z.ZodOptional<z.ZodString>;
+            /** The step ids still to do after this change. */
+            steps: z.ZodArray<z.ZodString, "many">;
+            /** The step ids the change dropped. */
+            dropped: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            dropped: string[];
+            reason?: string | undefined;
+        }, {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            reason?: string | undefined;
+            dropped?: string[] | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        steps: {
+            id: string;
+            title: string;
+        }[];
+        revisions: {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            dropped: string[];
+            reason?: string | undefined;
+        }[];
+        current?: {
+            id: string;
+            startedAt: string;
+        } | undefined;
+    }, {
+        steps: {
+            id: string;
+            title: string;
+        }[];
+        current?: {
+            id: string;
+            startedAt: string;
+        } | undefined;
+        revisions?: {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            reason?: string | undefined;
+            dropped?: string[] | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    followUp: boolean;
+    tags: string[];
+    approvedAtStart: boolean;
+    blocked?: {
+        at: string;
+        reason: string;
+        nodeId: string;
+    } | undefined;
+    plan?: {
+        steps: {
+            id: string;
+            title: string;
+        }[];
+        revisions: {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            dropped: string[];
+            reason?: string | undefined;
+        }[];
+        current?: {
+            id: string;
+            startedAt: string;
+        } | undefined;
+    } | undefined;
+    title?: string | undefined;
+    approved?: Record<string, string> | undefined;
+    requestId?: string | undefined;
+    startedBy?: string | undefined;
+    endNotifiedAt?: string | undefined;
+    wrap?: {
+        channel: string;
+        mode: "plan" | "linear";
+        agentId: string;
+        taskId?: string | undefined;
+    } | undefined;
+}, {
+    followUp?: boolean | undefined;
+    tags?: string[] | undefined;
+    blocked?: {
+        at: string;
+        reason: string;
+        nodeId: string;
+    } | undefined;
+    plan?: {
+        steps: {
+            id: string;
+            title: string;
+        }[];
+        current?: {
+            id: string;
+            startedAt: string;
+        } | undefined;
+        revisions?: {
+            at: string;
+            steps: string[];
+            kind: "plan" | "revise";
+            reason?: string | undefined;
+            dropped?: string[] | undefined;
+        }[] | undefined;
+    } | undefined;
+    title?: string | undefined;
+    approved?: Record<string, string> | undefined;
+    requestId?: string | undefined;
+    startedBy?: string | undefined;
+    approvedAtStart?: boolean | undefined;
+    endNotifiedAt?: string | undefined;
+    wrap?: {
+        channel: string;
+        mode: "plan" | "linear";
+        agentId: string;
+        taskId?: string | undefined;
+    } | undefined;
+}>;
+type RunMeta = z.infer<typeof runMetaSchema>;
+declare const workflowRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    workflowId: z.ZodString;
+    workflowVersion: z.ZodLiteral<2>;
+    homeNode: z.ZodString;
+    status: z.ZodEnum<["running", "paused", "completed", "failed", "canceled"]>;
+    pausedAt: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"checkpoint">;
+        nodeId: z.ZodString;
+        checkpointName: z.ZodString;
+        /** Filter applied to incoming events for resume. Same shape as the
+         *  matching trigger.channel filter. */
+        resumeMatch: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "checkpoint";
+        nodeId: string;
+        checkpointName: string;
+        resumeMatch: Record<string, unknown>;
+    }, {
+        kind: "checkpoint";
+        nodeId: string;
+        checkpointName: string;
+        resumeMatch?: Record<string, unknown> | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"subProcess">;
+        nodeId: z.ZodString;
+        childRunId: z.ZodString;
+        childWorkflowId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "subProcess";
+        nodeId: string;
+        childRunId: string;
+        childWorkflowId: string;
+    }, {
+        kind: "subProcess";
+        nodeId: string;
+        childRunId: string;
+        childWorkflowId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"signalWait">;
+        nodeId: z.ZodString;
+        signalName: z.ZodString;
+        /** Optional field-match filter against the emitted signal payload. */
+        match: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        scope: z.ZodDefault<z.ZodEnum<["workflow", "global"]>>;
+    }, "strip", z.ZodTypeAny, {
+        match: Record<string, unknown>;
+        kind: "signalWait";
+        scope: "workflow" | "global";
+        nodeId: string;
+        signalName: string;
+    }, {
+        kind: "signalWait";
+        nodeId: string;
+        signalName: string;
+        match?: Record<string, unknown> | undefined;
+        scope?: "workflow" | "global" | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"timerWait">;
+        nodeId: z.ZodString;
+        /** ISO-8601 instant when the timer should fire. */
+        fireAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "timerWait";
+        nodeId: string;
+        fireAt: string;
+    }, {
+        kind: "timerWait";
+        nodeId: string;
+        fireAt: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"ownerDecision">;
+        nodeId: z.ZodString;
+        cardId: z.ZodString;
+        purpose: z.ZodEnum<["ask", "send", "start"]>;
+        message: z.ZodOptional<z.ZodObject<{
+            channel: z.ZodString;
+            chatId: z.ZodString;
+            accountId: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+            to: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        }, {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "ownerDecision";
+        cardId: string;
+        nodeId: string;
+        purpose: "start" | "send" | "ask";
+        message?: {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        } | undefined;
+    }, {
+        kind: "ownerDecision";
+        cardId: string;
+        nodeId: string;
+        purpose: "start" | "send" | "ask";
+        message?: {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"replyWait">;
+        nodeId: z.ZodString;
+        channel: z.ZodString;
+        chatId: z.ZodString;
+        accountId: z.ZodOptional<z.ZodString>;
+        /** In a group: only this sender's message counts. */
+        from: z.ZodOptional<z.ZodString>;
+        deadline: z.ZodString;
+        nextRemindAt: z.ZodOptional<z.ZodString>;
+        remindEveryMs: z.ZodOptional<z.ZodNumber>;
+        reminders: z.ZodDefault<z.ZodNumber>;
+        maxReminders: z.ZodDefault<z.ZodNumber>;
+        /** A person.message step whose sent text the reminder repeats. Unset:
+         *  the reminder goes to the owner instead. */
+        reminds: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channel: string;
+        chatId: string;
+        kind: "replyWait";
+        reminders: number;
+        nodeId: string;
+        deadline: string;
+        maxReminders: number;
+        from?: string | undefined;
+        accountId?: string | undefined;
+        nextRemindAt?: string | undefined;
+        remindEveryMs?: number | undefined;
+        reminds?: string | undefined;
+    }, {
+        channel: string;
+        chatId: string;
+        kind: "replyWait";
+        nodeId: string;
+        deadline: string;
+        from?: string | undefined;
+        accountId?: string | undefined;
+        reminders?: number | undefined;
+        nextRemindAt?: string | undefined;
+        remindEveryMs?: number | undefined;
+        maxReminders?: number | undefined;
+        reminds?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"agentStep">;
+        nodeId: z.ZodString;
+        agentId: z.ZodString;
+        nudges: z.ZodDefault<z.ZodNumber>;
+        maxNudges: z.ZodDefault<z.ZodNumber>;
+        stallMs: z.ZodNumber;
+        nextNudgeAt: z.ZodOptional<z.ZodString>;
+        /** Set once the step is blocked: no more nudges, the owner is told. */
+        blocked: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "agentStep";
+        agentId: string;
+        nudges: number;
+        maxNudges: number;
+        nodeId: string;
+        stallMs: number;
+        blocked?: string | undefined;
+        nextNudgeAt?: string | undefined;
+    }, {
+        kind: "agentStep";
+        agentId: string;
+        nodeId: string;
+        stallMs: number;
+        blocked?: string | undefined;
+        nudges?: number | undefined;
+        maxNudges?: number | undefined;
+        nextNudgeAt?: string | undefined;
+    }>]>>;
+    /** Output bundles keyed by producing node id. Downstream nodes read via
+     *  `{{<nodeId>.<path>}}` in templates. */
+    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    /** Node ids queued for execution next. The walk driver pops from this
+     *  until it's empty or a checkpoint pauses the run. */
+    pending: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Per-`gateway.parallel(mode=join)` arrival tracker. Keys are join node
+     *  ids; values are the upstream node ids that have already delivered.
+     *  The join fires once when arrived.length === #incoming edges. Entries
+     *  are deleted from the map on fire so repeated passes (rare, but
+     *  possible via crash + retry) stay idempotent. */
+    joinCounters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    entityRef: z.ZodObject<{
+        backend: z.ZodString;
+        /** Stable identifier for the entity this run is scoped to. Used to key
+         *  the entity index so webhook re-entry can find the active run. */
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        backend: string;
+    }, {
+        id: string;
+        backend: string;
+    }>;
+    history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        nodeId: z.ZodString;
+        /** Which upstream node outputs fed this execution. Usually one id, or
+         *  empty for the trigger. */
+        inputKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        status: z.ZodEnum<["ok", "failed", "timeout", "skipped", "paused", "resumed"]>;
+        /** The node's output bundle, if successful. Stored here so the full run
+         *  history can be replayed without the live context. */
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Per-(runId, nodeId, eventId) key used to drop duplicate webhook
+         *  deliveries when a run is resumed from a checkpoint. */
+        idempotencyKey: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+        /** When the step began (#858). `at` is when it was recorded, so the
+         *  step took `durationMs` from here. Absent on entries written before. */
+        startedAt: z.ZodOptional<z.ZodString>;
+        /** How long the step ran, in milliseconds (#858). */
+        durationMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+        idempotencyKey: string;
+        nodeId: string;
+        inputKeys: string[];
+        output?: Record<string, unknown> | undefined;
+        durationMs?: number | undefined;
+        note?: string | undefined;
+        startedAt?: string | undefined;
+    }, {
+        at: string;
+        status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+        idempotencyKey: string;
+        nodeId: string;
+        output?: Record<string, unknown> | undefined;
+        durationMs?: number | undefined;
+        note?: string | undefined;
+        startedAt?: string | undefined;
+        inputKeys?: string[] | undefined;
+    }>, "many">>;
+    /** Parent run id if this run is a sub-process child. Root runs have no
+     *  parent. */
+    parentRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** The parent node in the parent run that spawned this child. Null on
+     *  root runs. */
+    parentNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Root ancestor. Self-referential on root runs. Lets queries fetch the
+     *  entire composition tree in one shot. */
+    rootRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Depth from root. 0 on root runs, N on Nth-level descendants. */
+    depth: z.ZodDefault<z.ZodNumber>;
+    /** Event-bus root the run was started under (src/events/envelope.ts).
+     *  Resumes after a pause or restart publish under it again. */
+    eventRootId: z.ZodOptional<z.ZodString>;
+    /** Follow-up runs only (#788). */
+    meta: z.ZodOptional<z.ZodObject<{
+        /** One line: what this run is doing, in the owner's words. */
+        title: z.ZodOptional<z.ZodString>;
+        /** What the run concerns, as "kind:name" (client:acme, employee:sam,
+         *  project:site, idea:newsletter). The progress view groups by these. */
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The agent that started it. */
+        startedBy: z.ZodOptional<z.ZodString>;
+        /** The open request (src/requests) this run serves. */
+        requestId: z.ZodOptional<z.ZodString>;
+        /** Followed: nudges, reminders, a blocked notice and one summary at
+         *  the end. */
+        followUp: z.ZodDefault<z.ZodBoolean>;
+        /** The owner approved this run's messages when it started. */
+        approvedAtStart: z.ZodDefault<z.ZodBoolean>;
+        /** The messages that approval covers, by step id: recipient and text as
+         *  the owner saw them (messageKey). Any other message is asked again. */
+        approved: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Why the run cannot go on without the owner, and when they were told. */
+        blocked: z.ZodOptional<z.ZodObject<{
+            nodeId: z.ZodString;
+            reason: z.ZodString;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            reason: string;
+            nodeId: string;
+        }, {
+            at: string;
+            reason: string;
+            nodeId: string;
+        }>>;
+        /** The owner got the end summary. Sent once. */
+        endNotifiedAt: z.ZodOptional<z.ZodString>;
+        /** A task run inside a workflow because `workflows.required` is on
+         *  (#858): the agent turn it wraps. `mode` is `linear` (the one-step
+         *  template) until the agent writes a plan. */
+        wrap: z.ZodOptional<z.ZodObject<{
+            agentId: z.ZodString;
+            channel: z.ZodString;
+            mode: z.ZodEnum<["linear", "plan"]>;
+            taskId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        }, {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        }>>;
+        /** The plan the agent wrote for a wrapped task, and each change to it. */
+        plan: z.ZodOptional<z.ZodObject<{
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                title: string;
+            }, {
+                id: string;
+                title: string;
+            }>, "many">;
+            /** The step the agent said it started, and when. */
+            current: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                startedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                startedAt: string;
+            }, {
+                id: string;
+                startedAt: string;
+            }>>;
+            revisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                at: z.ZodString;
+                /** `plan`: the first plan. `revise`: a change to the steps left. */
+                kind: z.ZodEnum<["plan", "revise"]>;
+                reason: z.ZodOptional<z.ZodString>;
+                /** The step ids still to do after this change. */
+                steps: z.ZodArray<z.ZodString, "many">;
+                /** The step ids the change dropped. */
+                dropped: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                dropped: string[];
+                reason?: string | undefined;
+            }, {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                reason?: string | undefined;
+                dropped?: string[] | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            revisions: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                dropped: string[];
+                reason?: string | undefined;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+        }, {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+            revisions?: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                reason?: string | undefined;
+                dropped?: string[] | undefined;
+            }[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        followUp: boolean;
+        tags: string[];
+        approvedAtStart: boolean;
+        blocked?: {
+            at: string;
+            reason: string;
+            nodeId: string;
+        } | undefined;
+        plan?: {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            revisions: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                dropped: string[];
+                reason?: string | undefined;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+        } | undefined;
+        title?: string | undefined;
+        approved?: Record<string, string> | undefined;
+        requestId?: string | undefined;
+        startedBy?: string | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | undefined;
+    }, {
+        followUp?: boolean | undefined;
+        tags?: string[] | undefined;
+        blocked?: {
+            at: string;
+            reason: string;
+            nodeId: string;
+        } | undefined;
+        plan?: {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+            revisions?: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                reason?: string | undefined;
+                dropped?: string[] | undefined;
+            }[] | undefined;
+        } | undefined;
+        title?: string | undefined;
+        approved?: Record<string, string> | undefined;
+        requestId?: string | undefined;
+        startedBy?: string | undefined;
+        approvedAtStart?: boolean | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | undefined;
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "completed" | "canceled" | "paused" | "running";
+    id: string;
+    context: Record<string, Record<string, unknown>>;
+    pending: string[];
+    updatedAt: string;
+    history: {
+        at: string;
+        status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+        idempotencyKey: string;
+        nodeId: string;
+        inputKeys: string[];
+        output?: Record<string, unknown> | undefined;
+        durationMs?: number | undefined;
+        note?: string | undefined;
+        startedAt?: string | undefined;
+    }[];
+    createdAt: string;
+    workflowVersion: 2;
+    workflowId: string;
+    homeNode: string;
+    joinCounters: Record<string, string[]>;
+    entityRef: {
+        id: string;
+        backend: string;
+    };
+    parentRunId: string | null;
+    parentNodeId: string | null;
+    rootRunId: string | null;
+    depth: number;
+    pausedAt?: {
+        kind: "checkpoint";
+        nodeId: string;
+        checkpointName: string;
+        resumeMatch: Record<string, unknown>;
+    } | {
+        kind: "subProcess";
+        nodeId: string;
+        childRunId: string;
+        childWorkflowId: string;
+    } | {
+        match: Record<string, unknown>;
+        kind: "signalWait";
+        scope: "workflow" | "global";
+        nodeId: string;
+        signalName: string;
+    } | {
+        kind: "timerWait";
+        nodeId: string;
+        fireAt: string;
+    } | {
+        kind: "ownerDecision";
+        cardId: string;
+        nodeId: string;
+        purpose: "start" | "send" | "ask";
+        message?: {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        } | undefined;
+    } | {
+        channel: string;
+        chatId: string;
+        kind: "replyWait";
+        reminders: number;
+        nodeId: string;
+        deadline: string;
+        maxReminders: number;
+        from?: string | undefined;
+        accountId?: string | undefined;
+        nextRemindAt?: string | undefined;
+        remindEveryMs?: number | undefined;
+        reminds?: string | undefined;
+    } | {
+        kind: "agentStep";
+        agentId: string;
+        nudges: number;
+        maxNudges: number;
+        nodeId: string;
+        stallMs: number;
+        blocked?: string | undefined;
+        nextNudgeAt?: string | undefined;
+    } | undefined;
+    eventRootId?: string | undefined;
+    meta?: {
+        followUp: boolean;
+        tags: string[];
+        approvedAtStart: boolean;
+        blocked?: {
+            at: string;
+            reason: string;
+            nodeId: string;
+        } | undefined;
+        plan?: {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            revisions: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                dropped: string[];
+                reason?: string | undefined;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+        } | undefined;
+        title?: string | undefined;
+        approved?: Record<string, string> | undefined;
+        requestId?: string | undefined;
+        startedBy?: string | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    status: "failed" | "completed" | "canceled" | "paused" | "running";
+    id: string;
+    updatedAt: string;
+    createdAt: string;
+    workflowVersion: 2;
+    workflowId: string;
+    homeNode: string;
+    entityRef: {
+        id: string;
+        backend: string;
+    };
+    context?: Record<string, Record<string, unknown>> | undefined;
+    pending?: string[] | undefined;
+    history?: {
+        at: string;
+        status: "timeout" | "ok" | "failed" | "skipped" | "resumed" | "paused";
+        idempotencyKey: string;
+        nodeId: string;
+        output?: Record<string, unknown> | undefined;
+        durationMs?: number | undefined;
+        note?: string | undefined;
+        startedAt?: string | undefined;
+        inputKeys?: string[] | undefined;
+    }[] | undefined;
+    pausedAt?: {
+        kind: "checkpoint";
+        nodeId: string;
+        checkpointName: string;
+        resumeMatch?: Record<string, unknown> | undefined;
+    } | {
+        kind: "subProcess";
+        nodeId: string;
+        childRunId: string;
+        childWorkflowId: string;
+    } | {
+        kind: "signalWait";
+        nodeId: string;
+        signalName: string;
+        match?: Record<string, unknown> | undefined;
+        scope?: "workflow" | "global" | undefined;
+    } | {
+        kind: "timerWait";
+        nodeId: string;
+        fireAt: string;
+    } | {
+        kind: "ownerDecision";
+        cardId: string;
+        nodeId: string;
+        purpose: "start" | "send" | "ask";
+        message?: {
+            text: string;
+            channel: string;
+            chatId: string;
+            to?: string | undefined;
+            accountId?: string | undefined;
+        } | undefined;
+    } | {
+        channel: string;
+        chatId: string;
+        kind: "replyWait";
+        nodeId: string;
+        deadline: string;
+        from?: string | undefined;
+        accountId?: string | undefined;
+        reminders?: number | undefined;
+        nextRemindAt?: string | undefined;
+        remindEveryMs?: number | undefined;
+        maxReminders?: number | undefined;
+        reminds?: string | undefined;
+    } | {
+        kind: "agentStep";
+        agentId: string;
+        nodeId: string;
+        stallMs: number;
+        blocked?: string | undefined;
+        nudges?: number | undefined;
+        maxNudges?: number | undefined;
+        nextNudgeAt?: string | undefined;
+    } | undefined;
+    joinCounters?: Record<string, string[]> | undefined;
+    parentRunId?: string | null | undefined;
+    parentNodeId?: string | null | undefined;
+    rootRunId?: string | null | undefined;
+    depth?: number | undefined;
+    eventRootId?: string | undefined;
+    meta?: {
+        followUp?: boolean | undefined;
+        tags?: string[] | undefined;
+        blocked?: {
+            at: string;
+            reason: string;
+            nodeId: string;
+        } | undefined;
+        plan?: {
+            steps: {
+                id: string;
+                title: string;
+            }[];
+            current?: {
+                id: string;
+                startedAt: string;
+            } | undefined;
+            revisions?: {
+                at: string;
+                steps: string[];
+                kind: "plan" | "revise";
+                reason?: string | undefined;
+                dropped?: string[] | undefined;
+            }[] | undefined;
+        } | undefined;
+        title?: string | undefined;
+        approved?: Record<string, string> | undefined;
+        requestId?: string | undefined;
+        startedBy?: string | undefined;
+        approvedAtStart?: boolean | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type WorkflowRun = z.infer<typeof workflowRunSchema>;
+
+interface RunStoreOptions {
+    baseDir?: string;
+    /** This daemon's mesh peer id. Stamped as `homeNode` on run creation so
+     *  later code can verify ownership before mutating. */
+    nodeId: string;
+}
+declare class RunStore {
+    readonly baseDir: string;
+    readonly runsDir: string;
+    readonly indexDir: string;
+    readonly nodeId: string;
+    constructor(opts: RunStoreOptions);
+    private runPath;
+    private indexPath;
+    /** Create a new run. Seeds the initial pending queue (typically the
+     *  trigger node's immediate successors) and writes an entity-index entry
+     *  so future events for the same entity land on this home node. */
+    create(args: {
+        workflowId: string;
+        initialPending: string[];
+        entityRef: EntityRef;
+        initialContext?: Record<string, Record<string, unknown>>;
+        /** Optional parent-run linkage for sub-process children. */
+        parentRunId?: string | null;
+        parentNodeId?: string | null;
+        rootRunId?: string | null;
+        depth?: number;
+        /** Defaults to the current event root, if any. */
+        eventRootId?: string;
+        /** Follow-up runs (#788): title, tags, who started it. */
+        meta?: RunMeta;
+        /** A run id chosen before the run exists (#858: the agent is told it
+         *  before its turn starts). Default: a fresh UUID. */
+        id?: string;
+    }): WorkflowRun;
+    /** Read the latest snapshot of a run by replaying the jsonl log. */
+    get(runId: string): WorkflowRun | null;
+    /** Look up the active run id for an entity, if any. */
+    getActiveByEntity(entity: EntityRef): string | null;
+    /** Which node owns a given entity (null if unclaimed). Used by the
+     *  dispatcher to decide whether to process locally or forward via mesh. */
+    getHomeNodeByEntity(entity: EntityRef): string | null;
+    /** Record a single node's execution. Appends an `exec` line and returns
+     *  the updated run snapshot. Idempotent: if an entry with the same
+     *  idempotencyKey already exists, the call is a no-op. */
+    recordExecution(args: {
+        runId: string;
+        entry: NodeExecutionEntry;
+        nextPending: string[];
+        status?: RunStatus;
+        pausedAt?: PausedAt | null;
+        /** Optional updated context snapshot. When provided, replaces the run's
+         *  context wholesale (used when a node's output bundle lands).  When
+         *  omitted, context is carried forward unchanged. */
+        context?: Record<string, Record<string, unknown>>;
+        /** Optional updated join-counter map. Undefined = carry forward. */
+        joinCounters?: Record<string, string[]>;
+    }): WorkflowRun | null;
+    /** Mutate status without adding a history entry — used for
+     *  pause / resume / cancel commands from the CLI or dashboard. */
+    setStatus(runId: string, status: RunStatus): WorkflowRun | null;
+    /** Merge fields into a run's meta (#788). Appends a snapshot, like
+     *  setStatus; history and context are carried over as they are. */
+    setMeta(runId: string, patch: Partial<RunMeta>): WorkflowRun | null;
+    /** Merge into a run's meta and replace its pending queue (#858: a plan
+     *  written or changed mid-run). Appends a snapshot; history is kept. */
+    patch(runId: string, patch: {
+        meta?: Partial<RunMeta>;
+        pending?: string[];
+    }): WorkflowRun | null;
+    /** Remove a run and its entity index entry, as if it never ran (#858: a
+     *  plain question exempted from workflows.required). */
+    discard(runId: string): boolean;
+    /** List runs, newest first. */
+    list(opts?: {
+        workflowId?: string;
+        limit?: number;
+    }): WorkflowRun[];
+    /** Retention: keep at most `maxRuns` completed/failed/canceled runs
+     *  younger than `maxDays`. Running/paused runs are never pruned. */
+    prune(policy: {
+        maxRuns: number;
+        maxDays: number;
+    }): number;
+    private appendSnapshot;
+    private writeIndex;
+    private clearIndex;
+}
+
 interface RunningTask {
     /** Unique id for this execution (timestamp-based). */
     id: string;
@@ -13216,6 +14588,15 @@ interface RunningTask {
     intentPath?: string[];
     /** Step autonomy the turn runs at (report | propose | act). Unset = act. */
     autonomy?: AgentTask["autonomy"];
+    /** The workflow run this turn belongs to (#858): a step of a run, or
+     *  the run a task is wrapped in under workflows.required. `step` and
+     *  `title` are filled in when the agent list is read. */
+    workflow?: {
+        runId: string;
+        workflowId?: string;
+        step?: string;
+        title?: string;
+    };
 }
 type TaskOutputSubscriber = (chunk: string) => void;
 /** Persisted record of a finished task, written to .agentx/task-history. */
@@ -13231,8 +14612,9 @@ interface TaskRecord {
     durationMs: number;
     ok: boolean;
     error?: string;
-    /** Set when a deadline ended the run: `timeout`, with the step it was in. */
-    status?: "timeout";
+    /** Set when a deadline ended the run: `timeout`, with the step it was in;
+     *  `stopped` when a stop signal ended it (#857). */
+    status?: "timeout" | "stopped";
     step?: string;
     /** Final agent text (one-shot, may be empty if streaming captured it). */
     responseText: string;
@@ -13283,6 +14665,9 @@ declare class AgentRegistry {
      *  its `action.send` / `agent` nodes. Duck-typed to avoid a circular import
      *  on WorkflowDispatcher. */
     private workflowAutoRunner?;
+    /** Where wrapped tasks keep their run (#858). Wired by the daemon with
+     *  the workflow engine's run store; unset means no wrapping. */
+    private workflowRuns?;
     private messageQueue;
     /**
      * Voice chats a waiting question has claimed between its wait ending and
@@ -13311,6 +14696,10 @@ declare class AgentRegistry {
     private taskAborts;
     /** Runs a daemon shutdown stopped, with the reason each one reports. */
     private interruptedRuns;
+    /** Runs a stop signal ended, with the reason each one reports (#857). */
+    private stoppedRuns;
+    /** Callers waiting for a run to let go of its slot (whenRunEnds). */
+    private runEndWaiters;
     /** Claude cloud sessions this node launched (#622), by issue. Created on
      *  first use so a fleet with the setting off never touches the file. */
     private cloudSessions?;
@@ -13344,6 +14733,7 @@ declare class AgentRegistry {
     /** Wire the workflow auto-runner — see field doc above. Daemon calls this
      *  after WorkflowDispatcher boot. Pass undefined to detach (e.g. during
      *  reload). */
+    setWorkflowRunStore(runs: RunStore | undefined): void;
     setWorkflowAutoRunner(runner: NonNullable<AgentRegistry["workflowAutoRunner"]> | undefined): void;
     /** Hot-swap the provider map. Daemon reload calls this after agentx.json
      *  changes — the next task that executes will resolve credentials through
@@ -13357,6 +14747,9 @@ declare class AgentRegistry {
      *  execute-time for landscape + session policies, so next-task semantics
      *  match setProviders. */
     setConfig(next: DaemonConfig): void;
+    /** Swap the workflows block on a config reload (#858): matching,
+     *  follow-up and required settings are read per turn. */
+    setWorkflows(workflows: DaemonConfig["workflows"]): void;
     /** Swap the people list on a config reload (#384). Turns read it when
      *  they start, so the next turn is stamped from the new list. */
     setPeople(people: DaemonConfig["people"]): void;
@@ -13494,6 +14887,9 @@ declare class AgentRegistry {
         };
         hourlyTasks?: number[];
     }>;
+    /** Running tasks with the workflow run each belongs to and the step it
+     *  is on (#858), read from the run store; the stored list is not touched. */
+    private withWorkflowSteps;
     /**
      * Write a finished task record to disk under .agentx/task-history/<agent>/<yyyy-mm-dd>/.
      * Side-effects only — call sites should treat failure as best-effort.
@@ -13556,6 +14952,7 @@ declare class AgentRegistry {
         taskId: string;
         context: NonNullable<AgentTask["context"]>;
         autonomy?: AgentTask["autonomy"];
+        workflowRunId?: string;
     } | null;
     /** Whether every slot of `agentId` is taken, and by which runs. Lets a
      *  synchronous delegation refuse at once when the only slot is held by
@@ -13585,6 +14982,34 @@ declare class AgentRegistry {
         channel: string;
         chatId: string;
     } | null;
+    /**
+     * Stop signal (#857). Aborts the run like an operator stop, but it ends
+     * with status `stopped` and errorKind "stopped" instead of cancelled, so
+     * nothing reports it as a failure. False when no live run matches.
+     */
+    stopRunningTask(taskId: string, reason: string): boolean;
+    /** Resolves once the run `taskId` has let go of its slot (at once when it
+     *  is not running), or after `timeoutMs`. */
+    whenRunEnds(taskId: string, timeoutMs: number): Promise<void>;
+    /** A running task a stop signal can address: by its id, or the only run
+     *  of `agentId` on a chat. Null when none (or several) match. */
+    signalTarget(by: {
+        taskId?: string;
+        agentId?: string;
+        channel?: string;
+        chatId?: string;
+    }): {
+        taskId: string;
+        traceId?: string;
+        agentId: string;
+        channel: string;
+        chatId: string;
+        sender?: string;
+        rootId?: string;
+        originalMessage: string;
+        origin: RunOrigin | null;
+        workflowRunId?: string;
+    } | null;
     /**
      * Daemon shutdown: stop every run still going once the drain limit is
      * spent. Each one ends as `interrupted` with `reason` rather than as a
@@ -14566,6 +15991,7 @@ interface Resumer {
         run: InterruptedRun;
         note: string;
         attempt: number;
+        rootId?: string;
     }): Promise<void>;
     /** One line to the chat the run came from. */
     tell?(origin: RunOrigin, text: string): Promise<void>;