agentix-cli 0.132.0 → 0.134.0

package/dist/index.d.ts

@@ -1619,6 +1619,17 @@ declare const agentConfigSchema: z.ZodObject<{
         }, {
             enabled?: boolean | undefined;
         }>>;
+        /** Where this agent's notes are, for `wiki query` when
+         *  `wiki.query.notes.enabled` (#862). Unset: the AgentX note store,
+         *  `.agentx/agent-memory/<agent>/`. A relative path is read from the
+         *  folder AgentX runs in. */
+        notes: z.ZodDefault<z.ZodObject<{
+            dir: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            dir?: string | undefined;
+        }, {
+            dir?: string | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         contribute: {
             enabled: boolean;
@@ -1629,6 +1640,9 @@ declare const agentConfigSchema: z.ZodObject<{
         absorb: {
             enabled: boolean;
         };
+        notes: {
+            dir?: string | undefined;
+        };
     }, {
         contribute?: {
             model?: string | undefined;
@@ -1639,6 +1653,9 @@ declare const agentConfigSchema: z.ZodObject<{
         absorb?: {
             enabled?: boolean | undefined;
         } | undefined;
+        notes?: {
+            dir?: string | undefined;
+        } | undefined;
     }>>;
     permissionMode: z.ZodDefault<z.ZodString>;
     /** How this agent's `claude` CLI is billed (claude-code tier). Default
@@ -2001,6 +2018,9 @@ declare const agentConfigSchema: z.ZodObject<{
         absorb: {
             enabled: boolean;
         };
+        notes: {
+            dir?: string | undefined;
+        };
     } | undefined;
     voice?: {
         system?: string | Record<string, string> | undefined;
@@ -2052,6 +2072,9 @@ declare const agentConfigSchema: z.ZodObject<{
         absorb?: {
             enabled?: boolean | undefined;
         } | undefined;
+        notes?: {
+            dir?: string | undefined;
+        } | undefined;
     } | undefined;
     voice?: {
         system?: string | Record<string, string> | undefined;
@@ -2557,6 +2580,17 @@ declare const daemonConfigSchema: z.ZodObject<{
             }, {
                 enabled?: boolean | undefined;
             }>>;
+            /** Where this agent's notes are, for `wiki query` when
+             *  `wiki.query.notes.enabled` (#862). Unset: the AgentX note store,
+             *  `.agentx/agent-memory/<agent>/`. A relative path is read from the
+             *  folder AgentX runs in. */
+            notes: z.ZodDefault<z.ZodObject<{
+                dir: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                dir?: string | undefined;
+            }, {
+                dir?: string | undefined;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             contribute: {
                 enabled: boolean;
@@ -2567,6 +2601,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb: {
                 enabled: boolean;
             };
+            notes: {
+                dir?: string | undefined;
+            };
         }, {
             contribute?: {
                 model?: string | undefined;
@@ -2577,6 +2614,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb?: {
                 enabled?: boolean | undefined;
             } | undefined;
+            notes?: {
+                dir?: string | undefined;
+            } | undefined;
         }>>;
         permissionMode: z.ZodDefault<z.ZodString>;
         /** How this agent's `claude` CLI is billed (claude-code tier). Default
@@ -2939,6 +2979,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb: {
                 enabled: boolean;
             };
+            notes: {
+                dir?: string | undefined;
+            };
         } | undefined;
         voice?: {
             system?: string | Record<string, string> | undefined;
@@ -2990,6 +3033,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb?: {
                 enabled?: boolean | undefined;
             } | undefined;
+            notes?: {
+                dir?: string | undefined;
+            } | undefined;
         } | undefined;
         voice?: {
             system?: string | Record<string, string> | undefined;
@@ -3114,16 +3160,43 @@ 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>;
             /** Other agents' pages shown beside them. */
             sharedCandidates: z.ZodDefault<z.ZodNumber>;
+            /** The asking agent's own notes, searched beside its pages by the
+             *  summaries method (#862). A note's `description` is its summary
+             *  line. Only the agent's own notes: a note is private to the agent
+             *  that wrote it. Off by default. */
+            notes: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                /** Note types searched. `user` and `feedback` notes describe a
+                 *  person or the agent's own working rules and stay out. */
+                types: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                /** Notes shown to the model that picks. */
+                candidates: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                types: string[];
+                candidates: number;
+            }, {
+                enabled?: boolean | undefined;
+                types?: string[] | undefined;
+                candidates?: number | undefined;
+            }>>;
             /** Most pages opened for one answer. */
             maxPages: z.ZodDefault<z.ZodNumber>;
             /** Characters of each opened page given to the answer. */
             pageChars: z.ZodDefault<z.ZodNumber>;
+            /** Pages linked from the picked ones also opened (#863), best
+             *  summary line against the question first. 0: none. */
+            linkedPages: z.ZodDefault<z.ZodNumber>;
+            /** Characters all linked pages together give to the answer. */
+            linkedChars: z.ZodDefault<z.ZodNumber>;
             /** Model that picks pages from the summary lines. */
             navigatorModel: z.ZodDefault<z.ZodString>;
             /** Model that writes the answer. */
@@ -3287,11 +3360,18 @@ declare const daemonConfigSchema: z.ZodObject<{
             }>>;
         }, "strip", z.ZodTypeAny, {
             method: "auto" | "summaries" | "catalog";
+            notes: {
+                enabled: boolean;
+                types: string[];
+                candidates: number;
+            };
             shared: boolean;
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
             pageChars: number;
+            linkedPages: number;
+            linkedChars: number;
             navigatorModel: string;
             answerModel: string;
             live: {
@@ -3325,11 +3405,18 @@ declare const daemonConfigSchema: z.ZodObject<{
             };
         }, {
             method?: "auto" | "summaries" | "catalog" | undefined;
+            notes?: {
+                enabled?: boolean | undefined;
+                types?: string[] | undefined;
+                candidates?: number | undefined;
+            } | undefined;
             shared?: boolean | undefined;
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
             pageChars?: number | undefined;
+            linkedPages?: number | undefined;
+            linkedChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
             live?: {
@@ -3371,8 +3458,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>;
@@ -3407,11 +3494,18 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         query: {
             method: "auto" | "summaries" | "catalog";
+            notes: {
+                enabled: boolean;
+                types: string[];
+                candidates: number;
+            };
             shared: boolean;
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
             pageChars: number;
+            linkedPages: number;
+            linkedChars: number;
             navigatorModel: string;
             answerModel: string;
             live: {
@@ -3466,11 +3560,18 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, {
         query?: {
             method?: "auto" | "summaries" | "catalog" | undefined;
+            notes?: {
+                enabled?: boolean | undefined;
+                types?: string[] | undefined;
+                candidates?: number | undefined;
+            } | undefined;
             shared?: boolean | undefined;
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
             pageChars?: number | undefined;
+            linkedPages?: number | undefined;
+            linkedChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
             live?: {
@@ -7374,6 +7475,31 @@ 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>;
+            /** Task runs that ended are removed after this many days (#883),
+             *  at boot and every few hours. 0 keeps them all. */
+            retentionDays: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            retentionDays: number;
+            exemptQuestions: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            retentionDays?: number | 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. */
@@ -7381,6 +7507,12 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         dir: string;
         enabled: boolean;
+        required: {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            retentionDays: number;
+            exemptQuestions: boolean;
+        };
         followUp: {
             enabled: boolean;
             agents: Record<string, boolean>;
@@ -7402,6 +7534,12 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        required?: {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            retentionDays?: number | undefined;
+            exemptQuestions?: boolean | undefined;
+        } | undefined;
         followUp?: {
             enabled?: boolean | undefined;
             agents?: Record<string, boolean> | undefined;
@@ -7976,6 +8114,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb: {
                 enabled: boolean;
             };
+            notes: {
+                dir?: string | undefined;
+            };
         } | undefined;
         voice?: {
             system?: string | Record<string, string> | undefined;
@@ -8054,11 +8195,18 @@ declare const daemonConfigSchema: z.ZodObject<{
     wiki: {
         query: {
             method: "auto" | "summaries" | "catalog";
+            notes: {
+                enabled: boolean;
+                types: string[];
+                candidates: number;
+            };
             shared: boolean;
             candidates: number;
             sharedCandidates: number;
             maxPages: number;
             pageChars: number;
+            linkedPages: number;
+            linkedChars: number;
             navigatorModel: string;
             answerModel: string;
             live: {
@@ -8685,6 +8833,12 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows: {
         dir: string;
         enabled: boolean;
+        required: {
+            enabled: boolean;
+            agents: Record<string, boolean>;
+            retentionDays: number;
+            exemptQuestions: boolean;
+        };
         followUp: {
             enabled: boolean;
             agents: Record<string, boolean>;
@@ -8874,6 +9028,9 @@ declare const daemonConfigSchema: z.ZodObject<{
             absorb?: {
                 enabled?: boolean | undefined;
             } | undefined;
+            notes?: {
+                dir?: string | undefined;
+            } | undefined;
         } | undefined;
         voice?: {
             system?: string | Record<string, string> | undefined;
@@ -9004,11 +9161,18 @@ declare const daemonConfigSchema: z.ZodObject<{
     wiki?: {
         query?: {
             method?: "auto" | "summaries" | "catalog" | undefined;
+            notes?: {
+                enabled?: boolean | undefined;
+                types?: string[] | undefined;
+                candidates?: number | undefined;
+            } | undefined;
             shared?: boolean | undefined;
             candidates?: number | undefined;
             sharedCandidates?: number | undefined;
             maxPages?: number | undefined;
             pageChars?: number | undefined;
+            linkedPages?: number | undefined;
+            linkedChars?: number | undefined;
             navigatorModel?: string | undefined;
             answerModel?: string | undefined;
             live?: {
@@ -9697,6 +9861,12 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows?: {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        required?: {
+            enabled?: boolean | undefined;
+            agents?: Record<string, boolean> | undefined;
+            retentionDays?: number | undefined;
+            exemptQuestions?: boolean | undefined;
+        } | undefined;
         followUp?: {
             enabled?: boolean | undefined;
             agents?: Record<string, boolean> | undefined;
@@ -10485,6 +10655,7 @@ declare class AgentXDaemon {
     private httpServer?;
     private attachSweep?;
     private callSweep?;
+    private taskRunPrune?;
     private webhooks;
     private github?;
     private webrtc?;
@@ -13248,6 +13419,1346 @@ 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;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"agentStop">;
+    nodeId: z.ZodString;
+    agentId: z.ZodString;
+    /** The stopped turn's running-task id: the stopped-task record. */
+    taskId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "agentStop";
+    agentId: string;
+    nodeId: string;
+    taskId?: string | undefined;
+}, {
+    kind: "agentStop";
+    agentId: string;
+    nodeId: string;
+    taskId?: 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;
+    }>>;
+    /** The run this one continues (#870): a wrapped task that was stopped,
+     *  then resumed, gets a new run that names the one the stop closed. */
+    continues: z.ZodOptional<z.ZodString>;
+}, "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;
+    continues?: 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;
+    continues?: 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;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"agentStop">;
+        nodeId: z.ZodString;
+        agentId: z.ZodString;
+        /** The stopped turn's running-task id: the stopped-task record. */
+        taskId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "agentStop";
+        agentId: string;
+        nodeId: string;
+        taskId?: string | undefined;
+    }, {
+        kind: "agentStop";
+        agentId: string;
+        nodeId: string;
+        taskId?: 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;
+        }>>;
+        /** The run this one continues (#870): a wrapped task that was stopped,
+         *  then resumed, gets a new run that names the one the stop closed. */
+        continues: z.ZodOptional<z.ZodString>;
+    }, "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;
+        continues?: 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;
+        continues?: 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" | "running" | "canceled" | "paused";
+    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;
+    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;
+        continues?: string | undefined;
+        startedBy?: string | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | undefined;
+    } | undefined;
+    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;
+    } | {
+        kind: "agentStop";
+        agentId: string;
+        nodeId: string;
+        taskId?: string | undefined;
+    } | undefined;
+    eventRootId?: string | undefined;
+}, {
+    status: "failed" | "completed" | "running" | "canceled" | "paused";
+    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;
+    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;
+        continues?: string | undefined;
+        startedBy?: string | undefined;
+        approvedAtStart?: boolean | undefined;
+        endNotifiedAt?: string | undefined;
+        wrap?: {
+            channel: string;
+            mode: "plan" | "linear";
+            agentId: string;
+            taskId?: string | undefined;
+        } | 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;
+    } | {
+        kind: "agentStop";
+        agentId: string;
+        nodeId: string;
+        taskId?: 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;
+}>;
+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;
+    /** Task runs (#883): kept out of runsDir. */
+    readonly tasksDir: string;
+    readonly nodeId: string;
+    constructor(opts: RunStoreOptions);
+    /** Where a run's file is: its folder by workflow id when known, else
+     *  whichever folder holds it. */
+    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;
+    private readRun;
+    /** 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. Task runs (#883) are left out unless
+     *  `tasks` says otherwise; `workflowId: "task"` lists only them. A run
+     *  file last written before `since` (ms) is skipped unread: a run starts
+     *  before its file's last write. */
+    list(opts?: {
+        workflowId?: string;
+        limit?: number;
+        tasks?: "exclude" | "include" | "only";
+        since?: number;
+    }): WorkflowRun[];
+    /** Task runs still open (#883): their entity index entry is kept until
+     *  they end, so this reads the open ones only, however many have ended.
+     *  An entry whose run is gone is removed. */
+    openTaskRunIds(): string[];
+    /** Retention for task runs (#883): remove ended task runs last written
+     *  more than `maxDays` ago. Only old files are read; open runs stay.
+     *  Returns how many were removed. */
+    pruneTaskRuns(maxDays: number): number;
+    /** Move task runs written to _runs before they had a folder of their own
+     *  (0.133.0) into _tasks. Once: a marker file records it is done. */
+    moveTaskRuns(): number;
+    /** 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;
@@ -13272,6 +14783,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. */
@@ -13340,6 +14860,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
@@ -13405,6 +14928,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
@@ -13418,6 +14942,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;
@@ -13555,6 +15082,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.
@@ -13617,6 +15147,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