qlogicagent 2.10.22 → 2.10.24

package/dist/types/orchestration/workflow/cron-schedule.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Deterministic cron schedule computation (plan M3 trigger layer).
+ *
+ * `validateCron` (trigger-validation.ts) guarantees a stored schedule is structurally valid; this
+ * module turns a validated cron string into a concrete "next fire time" so the in-process
+ * WorkflowScheduler can arm a timer. Pure, side-effect-free, and UTC-based for determinism — the
+ * scheduler injects its own clock, and tests pin time exactly. (A future local-timezone offset is a
+ * caller concern; the engine itself is UTC so the same input always yields the same output.)
+ *
+ * Grammar matches validateCron exactly: 5-field (min hour dom month dow) or 6-field (+ leading
+ * seconds); each field is a comma-list of star / star-step / value / range / stepped-range, with
+ * 3-letter month and day-of-week names, and dow accepting both 0 and 7 for Sunday.
+ */
+export interface ParsedCron {
+    hasSeconds: boolean;
+    seconds: Set<number>;
+    minutes: Set<number>;
+    hours: Set<number>;
+    /** days-of-month, 1-31 */
+    doms: Set<number>;
+    /** months, 1-12 */
+    months: Set<number>;
+    /** days-of-week, 0-6 (Sunday=0; 7 is normalized to 0) */
+    dows: Set<number>;
+    /** true ⇔ the day-of-month field is restricted (not "*") */
+    domRestricted: boolean;
+    /** true ⇔ the day-of-week field is restricted (not "*") */
+    dowRestricted: boolean;
+}
+/** Parse a validated cron string into expanded numeric sets. Throws on malformed input (fail-loud). */
+export declare function parseCron(cron: string): ParsedCron;
+/**
+ * The next instant strictly after `afterMs` (UTC epoch ms) that matches `cron`. Throws if no match
+ * exists within a ~5-year horizon (e.g. an impossible date like "0 0 30 2 *"). Deterministic: the
+ * same (cron, afterMs) always returns the same value.
+ */
+export declare function nextCronTime(cron: string, afterMs: number): number;

package/dist/types/orchestration/workflow/data-item.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Workflow data envelope (spec: workflow-dataflow-and-triggers-spec.md §A2).
+ *
+ * Control/data separation: DagScheduler manages control (ready/skip/loop/ports) and
+ * never touches these values. The runtime data-routing layer carries DataItem[] along
+ * data edges; NodeExecutors consume/produce them.
+ *
+ * Media travels by-ref (BinaryRef → content-addressed blob store), keeping the envelope
+ * small and hash-cacheable.
+ */
+/** A content-addressed reference to a large binary (image/video/audio), never inlined into json. */
+export interface BinaryRef {
+    /** Pointer into the engine-managed blob store; content-addressed hash. */
+    ref: string;
+    mimeType: string;
+    size: number;
+    fileName?: string;
+    meta?: Record<string, unknown>;
+}
+/** A single unit of data flowing through a port. Most nodes emit one item per port. */
+export interface DataItem {
+    /** Structured data — what expressions reference. */
+    json: Record<string, unknown>;
+    /** Large binaries by reference; kept out of json. */
+    binary?: Record<string, BinaryRef>;
+}
+/** Per-port payload: every port carries an array of items (supports fan-out / batching). */
+export type PortMap = Record<string, DataItem[]>;
+/** Convenience: wrap a plain object into a single-item DataItem. */
+export declare function item(json: Record<string, unknown>, binary?: Record<string, BinaryRef>): DataItem;
+/** Convenience: a single-item port map on the given port (default "default"). */
+export declare function singlePort(json: Record<string, unknown>, port?: string): PortMap;
+/**
+ * Stable content signature of a port map, for the run-from-node cache key (§A5).
+ * Binary participates via its content-addressed ref (not its bytes).
+ */
+export declare function signaturePortMap(ports: PortMap): string;
+/** Deterministic JSON stringify with sorted object keys (arrays keep order). */
+export declare function stableStringify(value: unknown): string;

package/dist/types/orchestration/workflow/expression.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Restricted workflow expression evaluator (spec: workflow-dataflow-and-triggers-spec.md §A3–A4,
+ * plan D6). Used to bind node params to upstream data.
+ *
+ * HARD SECURITY LINE: NO arbitrary JS eval. This is a tiny recursive-descent interpreter over a
+ * fixed grammar — property/index path access + a whitelist of pure functions only. Unattended
+ * triggers make eval an injection surface, so arbitrary script is explicitly out of v1.
+ *
+ * Supported:
+ *   - context roots: $input · $json · $node("name") · $now · $vars · $trigger
+ *   - accessors: `.prop` and `[index]` / `["key"]`
+ *   - literals: string ('..' / ".."), number, true/false/null
+ *   - whitelist functions: len, upper, lower, default, jsonpath, date
+ *
+ * fail-loud: unknown roots/functions, reads through null/undefined, and prototype-escape keys
+ * all throw. Absent *leaf* keys evaluate to undefined (so `default(x, fb)` works).
+ */
+import type { PortMap } from "./data-item.js";
+export interface ExpressionContext {
+    /** $input — this node's input ports. */
+    input?: PortMap;
+    /** $json — shorthand for the current item's json (typically input.default[0].json). */
+    json?: Record<string, unknown>;
+    /** $node("X") — completed upstream node outputs, keyed by node id/name. */
+    nodes?: Record<string, {
+        output: PortMap;
+    }>;
+    /** $now — injectable clock for determinism; defaults to real time. */
+    now?: () => Date;
+    /** $vars — workflow-level variables. */
+    vars?: Record<string, unknown>;
+    /** $trigger — trigger payload. */
+    trigger?: Record<string, unknown>;
+}
+/**
+ * Evaluate a single expression body (the text inside `{{ }}`, braces stripped).
+ * Returns the raw value (object/array/number/string/boolean/null/undefined).
+ */
+export declare function evaluateExpression(body: string, ctx: ExpressionContext): unknown;
+/**
+ * Resolve a binding template:
+ *   - exactly `{{ expr }}` (whole string) → returns the raw evaluated value (keeps type)
+ *   - text with embedded `{{ }}` → string interpolation (each sub-expression stringified;
+ *     a sub-expression resolving to null/undefined throws — fail-loud)
+ *   - no `{{ }}` → returned unchanged
+ */
+export declare function resolveBinding(template: string, ctx: ExpressionContext): unknown;
+/**
+ * Recursively resolve every string value in a params object against the context.
+ * Non-string leaves are returned untouched. Arrays and nested objects are walked.
+ */
+export declare function resolveParams(params: Record<string, unknown>, ctx: ExpressionContext): Record<string, unknown>;

package/dist/types/orchestration/workflow/host-executors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Host-backed NodeExecutors (M3 bridge contract; plan D12/D13, spec §B).
+ *
+ * The engine is a pure executor: kinds that need real-world capabilities (agent / tool / http /
+ * mcp / channel) are fulfilled by an injected `ExecutorHost`. In production the openclaw gateway
+ * (or the qlogicagent CLI host) provides a real host; the engine never imports those subsystems.
+ *
+ * These executors are REAL (not mocks): they read the node's resolved params + inputs and delegate
+ * to the host. fail-loud — invoking a host-backed kind with no host throws (no silent fallback).
+ */
+import type { NodeExecutor } from "./node-schema.js";
+/** The host-backed kinds. Register these into a NodeRegistry to enable agent/tool/http/mcp/channel. */
+export declare const hostExecutors: Record<string, NodeExecutor>;
+/** Host-backed kind names (used by callers to know which kinds need a host). */
+export declare const HOST_BACKED_KINDS: string[];

package/dist/types/orchestration/workflow/n8n-import.d.ts

@@ -0,0 +1,35 @@
+/**
+ * n8n workflow JSON import — read-format-only translator (plan M5 §2.1: "导入 n8n workflow JSON
+ * (读格式,不打包其代码)").
+ *
+ * Converts an n8n workflow export (its public JSON shape: `nodes` + `connections`) into our own
+ * WorkflowDef. This reads n8n's data FORMAT only — it links/embeds NONE of n8n's runtime code, so
+ * the SUL licensing concern (plan §2.1 / risk register) does not apply.
+ *
+ * Fail-loud, single-track (§1.5): the type map is CURATED. An unknown node type, an unmodeled
+ * multi-output port, a connection referencing a missing node, or a malformed top-level shape is
+ * REJECTED with a clear error — never silently coerced to a generic/passthrough fallback. The
+ * converted def is returned raw; the caller runs it through `validateWorkflowDef` (every write path
+ * does) so graph invariants are enforced by the single existing gate, not duplicated here.
+ *
+ * Out of scope (intentionally, to avoid fabricating config): deriving a workflow-level TriggerDef
+ * from n8n's structured trigger params. Recognized trigger nodes map to our `trigger` entry kind
+ * (preserving their original type + params for visibility); the real schedule/webhook TriggerDef is
+ * set afterward through the validated set_trigger channel.
+ */
+import type { WorkflowDef } from "./node-schema.js";
+export interface N8nImportResult {
+    name: string;
+    def: WorkflowDef;
+}
+/** Thrown when an n8n workflow cannot be faithfully translated. Carries every problem found. */
+export declare class N8nImportError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+/**
+ * Convert an n8n workflow (a JSON string or already-parsed object) into a WorkflowDef.
+ * The returned def is NOT yet graph-validated — pass it to `validateWorkflowDef` / a controller
+ * write path, which is the single existing invariant gate.
+ */
+export declare function convertN8nWorkflow(input: string | unknown, workflowId: string): N8nImportResult;

package/dist/types/orchestration/workflow/node-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * NodeExecutor registry (M2; plan §M2 "NodeExecutor 注册表").
+ *
+ * Single source of truth mapping node `kind` → executor. fail-loud on unknown kinds and
+ * duplicate registration. Built-in deterministic executors (set / if / merge) register here;
+ * host-backed executors (agent / tool / http / mcp / channel) are injected by the host so the
+ * engine stays a pure executor (plan D12/D13).
+ */
+import type { NodeExecutor } from "./node-schema.js";
+export declare class NodeRegistry {
+    private executors;
+    constructor(includeBuiltins?: boolean);
+    register(kind: string, executor: NodeExecutor): void;
+    /** Replace an existing executor (e.g. host overrides a built-in). Must already exist. */
+    override(kind: string, executor: NodeExecutor): void;
+    has(kind: string): boolean;
+    get(kind: string): NodeExecutor;
+    kinds(): string[];
+}

package/dist/types/orchestration/workflow/node-schema.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Workflow node schema + NodeExecutor contract (M2; plan D10, spec §A1/§A6).
+ *
+ * One declarative schema, three consumers: inline UI (M4) / execution (here) / NL generation (M5).
+ * Control/data separation (spec §A1): the DagScheduler owns control; executors are pure data
+ * transforms `(inputs, params, ctx) → { outputs, firedPorts }`.
+ */
+import type { DataItem, PortMap } from "./data-item.js";
+/** Port type for connection validation (spec §A6). "any" connects to anything. */
+export type PortType = "any" | "string" | "number" | "boolean" | "json" | "image" | "video" | "audio" | "binary";
+export interface PortDef {
+    name: string;
+    type?: PortType;
+}
+/** Declarative workflow node (persisted; may carry `{{ }}` expressions in params). */
+export interface WorkflowNodeDef {
+    id: string;
+    kind: string;
+    /** Optional human-friendly display name (rename_node patch op; spec D17 §C). */
+    name?: string;
+    params?: Record<string, unknown>;
+    /** Output ports; default ["default"]. if→["true","false"], loop→["loop","done"]. */
+    outPorts?: string[];
+    /** Input ports (for type-checked routing); default ["default"]. */
+    inPorts?: PortDef[];
+    joinPolicy?: "all" | "any";
+    maxIterations?: number;
+}
+/** A data edge (carries DataItem[]). fromPort/toPort default "default". */
+export interface DataEdge {
+    from: string;
+    to: string;
+    fromPort?: string;
+    toPort?: string;
+    loopBack?: boolean;
+}
+export interface WorkflowDef {
+    id: string;
+    nodes: WorkflowNodeDef[];
+    edges: DataEdge[];
+    /** Workflow-level variables exposed to expressions as $vars. */
+    vars?: Record<string, unknown>;
+}
+export interface ExecutorContext {
+    nodeId: string;
+    kind: string;
+    /** 0-based; increments per loop iteration (drives the cache key, spec §A5). */
+    runIndex: number;
+    vars: Record<string, unknown>;
+    trigger?: Record<string, unknown>;
+    /** Injected clock for determinism. */
+    now: () => Date;
+    log?: {
+        info(m: string): void;
+        warn(m: string): void;
+    };
+    /** Host capabilities for host-backed node kinds (agent/tool/http/mcp/channel), D13. */
+    host?: ExecutorHost;
+    /** Cooperative cancellation for long-running host calls. */
+    signal?: AbortSignal;
+}
+/**
+ * Capabilities the HOST (openclaw gateway, or the qlogicagent CLI host) provides to back node
+ * kinds the engine cannot fulfil on its own. The engine stays a pure executor (plan D12/D13):
+ * agent/tool/mcp/http are qlogicagent-owned host capabilities; channel/IM call back into the
+ * openclaw channel layer. fail-loud: a host-backed kind with no host throws.
+ */
+export interface ExecutorHost {
+    /** Run an agent turn. Returns the agent's structured output as DataItem(s). */
+    runAgent(req: AgentHostRequest): Promise<DataItem[]>;
+    /** Invoke a qlogicagent tool by name. */
+    invokeTool(req: ToolHostRequest): Promise<DataItem[]>;
+    /** Perform an HTTP request (credentials resolved host-side). */
+    httpRequest(req: HttpHostRequest): Promise<DataItem[]>;
+    /** Invoke an MCP server tool. */
+    invokeMcp(req: McpHostRequest): Promise<DataItem[]>;
+    /** Send a message out through a channel (飞书/微信/…) via the openclaw channel layer. */
+    sendChannel(req: ChannelHostRequest): Promise<DataItem[]>;
+}
+export interface AgentHostRequest {
+    agentId?: string;
+    prompt: string;
+    input: DataItem[];
+    signal?: AbortSignal;
+}
+export interface ToolHostRequest {
+    tool: string;
+    args: Record<string, unknown>;
+    input: DataItem[];
+    signal?: AbortSignal;
+}
+export interface HttpHostRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+}
+export interface McpHostRequest {
+    server: string;
+    tool: string;
+    args: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface ChannelHostRequest {
+    channel: string;
+    target?: string;
+    payload: unknown;
+    input: DataItem[];
+    signal?: AbortSignal;
+}
+export interface NodeExecResult {
+    /** outPort → DataItem[]. */
+    outputs: PortMap;
+    /** Control nodes (if/loop) set this; data nodes omit → all outPorts fire. */
+    firedPorts?: string[];
+}
+/** A node executor: pure with respect to (inputs, params, ctx). NO hidden global state. */
+export type NodeExecutor = (inputs: PortMap, params: Record<string, unknown>, ctx: ExecutorContext) => Promise<NodeExecResult> | NodeExecResult;

package/dist/types/orchestration/workflow/qla-executor-host.d.ts

@@ -0,0 +1,42 @@
+/**
+ * QlogicagentExecutorHost — the REAL host backing host-executors (agent/tool/http/mcp/channel)
+ * with qlogicagent's actual capabilities. No mocks, no stubs (plan §1.5).
+ *
+ * Boundary capabilities (runAgent / invokeMcp / sendChannel) are injected so this file stays
+ * decoupled from the handler host that owns processManager/acpDetector and the openclaw channel
+ * callback. Tool invocation goes straight through the single-source-of-truth tool registry
+ * (`findTool`). fail-loud everywhere: unknown tool, missing channel host, or any rejection throws.
+ */
+import type { PortableTool } from "../../skills/portable-tool.js";
+import type { ExecutorHost } from "./node-schema.js";
+/** Injected boundary capabilities — supplied by the handler host that owns the real runners. */
+export interface QlaExecutorHostDeps {
+    /** Run one agent turn (spawn external ACP agent + sendTask). Returns the agent's text output. */
+    runAgent: (req: {
+        agentId?: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }) => Promise<string>;
+    /** Invoke an MCP server tool through the real MCP bridge. */
+    invokeMcp: (req: {
+        server: string;
+        tool: string;
+        args: Record<string, unknown>;
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+    /**
+     * Send a message out through a channel via the openclaw channel layer.
+     * Undefined in standalone qlogicagent (no gateway) → channel nodes fail-loud (D12/D13).
+     */
+    sendChannel?: (req: {
+        channel: string;
+        target?: string;
+        payload: unknown;
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+    /** Tool lookup; defaults to the real registry. Injectable for tests. */
+    findTool?: (name: string) => PortableTool | undefined;
+    /** fetch impl; defaults to global fetch. Injectable for tests. */
+    fetchImpl?: typeof fetch;
+}
+export declare function createQlaExecutorHost(deps: QlaExecutorHostDeps): ExecutorHost;

package/dist/types/orchestration/workflow/run-checkpoint-store.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Run Checkpoint Store — durable crash-restart recovery for in-flight workflow runs (plan §M3).
+ *
+ * The runtime's output cache is content-addressed (key = hash(kind + params + input signature +
+ * runIndex), spec §A5). Persisting that cache to disk turns run-from-node into crash recovery:
+ * after a qlogicagent restart, a FRESH WorkflowRuntime replays the same DAG, recomputes the same
+ * cache keys, and hits the persisted entries for every node that already completed — so those
+ * executors are NOT re-invoked (no duplicate agent turns / channel sends), and only the
+ * not-yet-run remainder executes. This is exactly the M3 acceptance:
+ * "qlogicagent 崩溃重启从 checkpoint 恢复在跑工作流".
+ *
+ * Stored at `<project>/.qlogicagent/workflows/<workflowId>/runs/<runId>/cache.json`.
+ * NodeExecResult is JSON (PortMap of DataItems + firedPorts), so the snapshot round-trips losslessly.
+ *
+ * fail-loud: a corrupt/unreadable snapshot is treated as absent (a fresh run), never silently
+ * partially applied.
+ */
+import type { NodeExecResult } from "./node-schema.js";
+/** One persisted cache entry: a content key and the executor result it produced. */
+export interface CheckpointEntry {
+    key: string;
+    result: NodeExecResult;
+}
+/** A point-in-time snapshot of a run's content-addressed output cache. */
+export interface CheckpointSnapshot {
+    workflowId: string;
+    runId: string;
+    entries: CheckpointEntry[];
+    updatedAt: string;
+}
+/**
+ * Durable run state the runtime loads on (re)start and persists after each computed node.
+ * Implementations may be file-backed (production) or in-memory (tests).
+ */
+export interface RunCheckpoint {
+    /** Load the prior snapshot, or undefined for a never-started / absent run. */
+    load(): Promise<CheckpointSnapshot | undefined>;
+    /** Persist the full set of computed cache entries (idempotent overwrite). */
+    persist(entries: CheckpointEntry[]): Promise<void>;
+    /** Remove the snapshot once the run has completed successfully. */
+    clear(): Promise<void>;
+}
+/** File-backed checkpoint under `.qlogicagent/workflows/<id>/runs/<runId>/cache.json`. */
+export declare class FileRunCheckpoint implements RunCheckpoint {
+    private readonly workflowId;
+    private readonly runId;
+    private readonly dir;
+    private readonly file;
+    constructor(cwd: string, workflowId: string, runId: string);
+    load(): Promise<CheckpointSnapshot | undefined>;
+    persist(entries: CheckpointEntry[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/orchestration/workflow/trigger-validation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Trigger validation — deterministic, fail-loud gate for workflow trigger configs (plan D7/D15).
+ *
+ * Triggers are the unattended entry points to a workflow (schedule/im-message/webhook/manual). A
+ * malformed trigger (an unparseable cron, a non-path webhook, an uncompilable IM match regex) must
+ * be rejected at the SINGLE mutation channel (`applyPatch` set_trigger), not silently persisted to
+ * fail later inside the gateway trigger layer where it is unreachable to fix. This keeps §1.5
+ * fail-loud and satisfies D15 ("schedule 须有效 cron / webhook 鉴权+限流" preconditions).
+ *
+ * Pure functions, no I/O, no side effects — the gateway still owns actual registration/auth/rate
+ * limiting; this only guarantees the stored config is structurally valid and runnable.
+ */
+import type { TriggerDef } from "./workflow-trigger.js";
+/** Returns a list of human-readable errors; empty ⇒ the trigger is valid. */
+export declare function validateTrigger(trigger: TriggerDef): string[];
+/**
+ * Validate a 5-field (min hour dom month dow) or 6-field (sec + the same) cron expression.
+ * Each field accepts a star, a star-step (every-N), a single value, a range, a stepped range, and
+ * comma-lists of those. Month and day-of-week additionally accept their 3-letter names.
+ * Day-of-week allows 0 and 7 for Sunday.
+ */
+export declare function validateCron(cron: string): string[];

package/dist/types/orchestration/workflow/workflow-controller.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Workflow Controller — automation driver: create / run / pause / resume + concurrency (spec §B4/B5).
+ *
+ * Owns workflow lifecycle on top of the WorkflowStore (persistence) and WorkflowRuntime (execution).
+ * Concurrency (spec §B5): when a workflow is triggered while a previous run is still in-flight, the
+ * record's `concurrency` policy decides:
+ *   - "skip"     → drop the new trigger (returns status "skipped")
+ *   - "queue"    → run after the current one finishes, reusing the runtime so its output cache
+ *                  survives → resume / run-from-node semantics hold
+ *   - "parallel" → start a fresh independent runtime concurrently (own cache)
+ *
+ * The caller supplies a `runtimeFactory` so host capabilities (D13), the node registry, the
+ * budget/permission gate (D15), and the clock are injected per workflow — the controller never
+ * imports those subsystems (engine stays a pure executor; plan D12).
+ *
+ * fail-loud: unknown workflow ids throw; executor/gate errors propagate out of run().
+ */
+import type { RunResult, WorkflowRuntime } from "./workflow-runtime.js";
+import type { NodeRegistry } from "./node-registry.js";
+import type { ExecutorHost } from "./node-schema.js";
+import { type WorkflowTriggerKind } from "./budget-permission-gate.js";
+import type { WorkflowDef } from "./node-schema.js";
+import { type PatchEnvelope, type WorkflowPatch } from "./workflow-patch.js";
+import { type RenderOptions } from "./workflow-render.js";
+import { WorkflowStore, type ConcurrencyPolicy, type WorkflowRecord } from "./workflow-store.js";
+export interface TriggerEvent {
+    type: WorkflowTriggerKind;
+    payload?: Record<string, unknown>;
+}
+/**
+ * Per-run context handed to the RuntimeFactory: the trigger KIND (so the factory can wire the D15
+ * permission gate — unattended kinds are restricted) plus its payload (exposed to expressions).
+ */
+export interface RunContext {
+    type: WorkflowTriggerKind;
+    payload?: Record<string, unknown>;
+}
+/** Builds a runtime for a workflow run. `ctx` carries the run's trigger kind + payload (spec §B3). */
+export type RuntimeFactory = (def: WorkflowDef, ctx: RunContext) => WorkflowRuntime;
+export interface RunOutcome {
+    workflowId: string;
+    status: "completed" | "failed" | "paused" | "skipped";
+    /** Absent when status === "skipped" (a busy run under the "skip" policy). */
+    result?: RunResult;
+}
+export interface CreateInput {
+    id: string;
+    name: string;
+    def: WorkflowDef;
+    concurrency?: ConcurrencyPolicy;
+    active?: boolean;
+}
+/** Result of a `patch()` call (spec §C `WorkflowToolResult`). */
+export type PatchOutcome = {
+    ok: true;
+    rev: number;
+    applied: WorkflowPatch[];
+} | {
+    ok: false;
+    conflict: {
+        latestRev: number;
+    };
+};
+export declare class WorkflowController {
+    private readonly store;
+    private readonly runtimeFactory;
+    private readonly slots;
+    constructor(store: WorkflowStore, runtimeFactory: RuntimeFactory);
+    create(input: CreateInput): Promise<WorkflowRecord>;
+    update(id: string, patch: Partial<Pick<WorkflowRecord, "name" | "def" | "concurrency" | "active">>): Promise<WorkflowRecord>;
+    setActive(id: string, active: boolean): Promise<WorkflowRecord>;
+    /**
+     * Import an n8n workflow JSON (read-format only, plan M5 §2.1) into the single store. Converts
+     * via the deterministic translator then routes through `create`, so the graph passes the same
+     * `validateWorkflowDef` gate every write path uses — fail-loud on unsupported nodes or bad graph.
+     */
+    importN8n(id: string, json: string | unknown, opts?: {
+        concurrency?: ConcurrencyPolicy;
+    }): Promise<WorkflowRecord>;
+    /** Load a single record or throw (fail-loud lookup; used by the scheduler to re-read triggers). */
+    get(id: string): Promise<WorkflowRecord>;
+    /**
+     * Render a workflow as compact agent-context text (spec §B / §A `get`). Fail-loud on unknown id.
+     * This is the engine half of the agent `workflow.get`/describe action: the agent reads this and
+     * emits a WorkflowPatch against the shown `rev`.
+     */
+    describe(id: string, opts?: RenderOptions): Promise<string>;
+    /**
+     * Apply a WorkflowPatch — the single mutation channel for agent edits and canvas hand-edits
+     * (spec §C). Loads the latest record, applies the patch transactionally through the engine
+     * (scope enforcement + validateDag), bumps `rev`, and persists. Optimistic concurrency (LWW):
+     *   - baseRev omitted or == current rev → apply against the latest.
+     *   - baseRev < current rev (someone edited in between) → replay onto the latest; if every op
+     *     still references valid nodes/edges it applies (last-write-wins), otherwise a conflict is
+     *     returned so the caller can redo against the latest rendering.
+     * A rejected patch (illegal op / scope violation / invalid graph) throws PatchError unchanged.
+     */
+    patch(id: string, env: PatchEnvelope): Promise<PatchOutcome>;
+    /** Trigger a run, honoring the workflow's concurrency policy (spec §B5). */
+    run(id: string, trigger?: TriggerEvent): Promise<RunOutcome>;
+    /** Cooperatively pause the in-flight run; it suspends before the next node (cache retained). */
+    pause(id: string): void;
+    /** Resume a paused workflow: re-run the same runtime so cached nodes hit and only the
+     * unfinished remainder executes. When the run paused on an exhausted budget, pass `extraBudget`
+     * to raise the gate's ceiling first (D15 "抬预算后 resume"); otherwise the first not-yet-run
+     * node would immediately re-trip the same budget and pause again. */
+    resume(id: string, opts?: {
+        extraBudget?: {
+            executions?: number;
+            durationMs?: number;
+        };
+    }): Promise<RunOutcome>;
+    /** Active workflows whose triggers the gateway should re-register after restart (spec §B4). */
+    listActive(): Promise<WorkflowRecord[]>;
+    private slotFor;
+    /**
+     * Track a fresh or queued run on the slot. `chained` runs wait for the slot's tail (the prior
+     * run) before starting → strict serialization for the "queue" policy. `pending` is incremented
+     * synchronously so concurrent triggers observe the slot as busy across the run→queue handoff.
+     */
+    private track;
+    private startParallel;
+}
+/**
+ * The production RuntimeFactory: builds a WorkflowRuntime wired with the D15 BudgetPermissionGate
+ * derived from the run's trigger kind. This is the consumer that turns the gate from a bare
+ * interface into an enforced guarantee — every run the controller starts through this factory has
+ * its per-run budget and (for unattended triggers) its permission allowlist checked before each
+ * node. Hosts supply the registry/host capabilities and the budget ceilings; the gate wiring is
+ * fixed so no run can accidentally execute ungated.
+ */
+export declare function defaultRuntimeFactory(opts: {
+    registry?: NodeRegistry;
+    host?: ExecutorHost;
+    /** Per-run budget ceilings (D15 "每轮过 budget"). maxNodeExecutions is required and must be > 0. */
+    budget: {
+        maxNodeExecutions: number;
+        maxDurationMs?: number;
+    };
+    /** Sensitive kinds an unattended run may execute (D15 permission gate). */
+    allowUnattendedKinds?: readonly string[];
+    now?: () => Date;
+}): RuntimeFactory;