qlogicagent 2.24.1 → 2.24.2

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

@@ -1,103 +0,0 @@
-/**
- * Run History Store — durable per-workflow run records (闭环 "察" 半场).
- *
- * The checkpoint store (run-checkpoint-store.ts) is an execution cache that is
- * DELETED when a run completes — it cannot answer "what did the last run do?".
- * This store keeps a bounded, append-style history per workflow so the canvas
- * can show past runs and per-node outputs:
- *
- *   `<project>/.qlogicagent/workflows/<workflowId>/runs/history.json`
- *
- * Recording happens in WorkflowController.run() — the single choke point every
- * trigger path goes through (manual RPC, cron scheduler, IM, webhook) — so
- * scheduled runs are captured identically to manual ones.
- *
- * Node outputs are stored as TRUNCATED JSON previews (default-port items'
- * `json`), not full PortMaps: history is for inspection, the checkpoint cache
- * remains the execution-fidelity layer. Bounded to the most recent
- * MAX_RUN_HISTORY entries; corrupt/missing history degrades to empty (history
- * must never block a run).
- */
-import type { RunResult } from "./workflow-runtime.js";
-import { type WorkflowError } from "./workflow-error.js";
-export declare const MAX_RUN_HISTORY = 20;
-export type RunHistoryStatus = "running" | "completed" | "failed" | "paused" | "skipped" | "canceled";
-export interface RunNodeActivity {
-    ts: string;
-    phase: "started" | "waiting" | "generating" | "tool_call" | "tool_result" | "completed" | "failed";
-    label: string;
-    detail?: string;
-}
-export interface RunNodeRecord {
-    /** Whether the node's executor actually ran (false = checkpoint cache hit). */
-    executed: boolean;
-    /** Truncated JSON preview of the node's output items (port → items[].json). */
-    preview: string;
-    seq?: number;
-    startedAt?: string;
-    durationMs?: number;
-    attempts?: number;
-    cacheHit?: boolean;
-    /** Per-node disposition; "failed" with a surviving run = onError errorPort/continue (D32). */
-    nodeStatus?: "running" | "completed" | "failed";
-    /** Safe execution-stage timeline. Never contains model chain-of-thought or raw tool arguments. */
-    activities?: RunNodeActivity[];
-    /** Live/terminal node error, when available. */
-    error?: string;
-    /** Engine-imposed limit surfaced on this node (e.g. a loop forced out at its iteration cap). */
-    warning?: string;
-}
-export interface RunHistoryEntry {
-    runId: string;
-    status: RunHistoryStatus;
-    triggerType: string;
-    startedAt: string;
-    finishedAt?: string;
-    durationMs?: number;
-    error?: string;
-    /** AI-5 (D49): classified, human-readable form of `error` (人话 + class + 0-死端 next-step actions). */
-    errorInfo?: WorkflowError;
-    /** AI-5: node that caused a "failed" run — precise canvas attribution. Hard-stop failures reject
-     *  without node records, so the runtime tags the failing node onto the thrown error. */
-    failedNodeId?: string;
-    /** nodeId → output record. Present once the run settles (not while running). */
-    nodes?: Record<string, RunNodeRecord>;
-}
-export interface RecoverableWorkflowRun {
-    runId: string;
-    triggerType: string;
-    startedAt: string;
-    triggerPayload?: Record<string, unknown>;
-}
-export type RunHistorySummary = Omit<RunHistoryEntry, "nodes">;
-/** Build per-node output previews (+ D33 trace stats) from a settled RunResult. */
-export declare function buildNodeRecords(result: RunResult): Record<string, RunNodeRecord>;
-export declare class WorkflowRunHistoryStore {
-    private readonly cwd;
-    private readonly mutationChains;
-    constructor(cwd: string);
-    /** Record a run start. Prepends a "running" entry and prunes to the bound. */
-    begin(workflowId: string, entry: Pick<RunHistoryEntry, "runId" | "triggerType" | "startedAt"> & {
-        triggerPayload?: Record<string, unknown>;
-    }): Promise<void>;
-    /** Settle a run entry (status/outputs/error). Unknown runId is a no-op (pruned entry). */
-    finish(workflowId: string, runId: string, patch: Partial<Pick<RunHistoryEntry, "status" | "finishedAt" | "durationMs" | "error" | "failedNodeId" | "nodes">>): Promise<void>;
-    /** Persist live node state so a refreshed/reconnected UI can reconstruct the active run. */
-    recordNodeStatus(workflowId: string, runId: string, nodeId: string, status: "running" | "completed" | "failed", error?: string): Promise<void>;
-    /** Append a redacted, user-facing execution stage for a running node. */
-    recordNodeActivity(workflowId: string, runId: string, nodeId: string, activity: Omit<RunNodeActivity, "ts"> & {
-        ts?: string;
-    }): Promise<void>;
-    /** Most-recent-first run summaries (no node outputs — those stay behind get()). */
-    list(workflowId: string): Promise<RunHistorySummary[]>;
-    /** Full entry incl. per-node output previews. */
-    get(workflowId: string, runId: string): Promise<RunHistoryEntry | undefined>;
-    /** Host-only view for reconstructing runs left in-flight by an abrupt process exit. */
-    recoverableRunning(workflowId: string): Promise<RecoverableWorkflowRun[]>;
-    /** Reclassify on read so historical records benefit from newer user-facing diagnostics. */
-    private withCurrentErrorInfo;
-    private waitForMutations;
-    private mutate;
-    private read;
-    private write;
-}

package/dist/types/orchestration/workflow/semantic-acceptance.d.ts

@@ -1,65 +0,0 @@
-import type { CapabilityEntry } from "./capability-catalog.js";
-import type { WorkflowDef } from "./node-schema.js";
-import type { TriggerDef } from "./workflow-patch.js";
-import type { WorkflowIntentContract } from "./workflow-intent-contract.js";
-export type WorkflowSemanticCheck = {
-    type: "trigger_type";
-    triggerType: TriggerDef["type"];
-} | {
-    type: "capability_present";
-    capabilityId: string;
-    minCount?: number;
-} | {
-    type: "node_kind_count";
-    kind: string;
-    min?: number;
-    max?: number;
-} | {
-    type: "path";
-    from: string;
-    to: string;
-    ordered?: string[];
-} | {
-    type: "terminal_kind";
-    kind: string;
-} | {
-    type: "param_equals";
-    node: string;
-    field: string;
-    value: unknown;
-};
-export interface WorkflowSemanticCriterion {
-    id: string;
-    description: string;
-    check: WorkflowSemanticCheck;
-    /** Optional evidence link; it does not turn an intent fact into a completion gate. */
-    intentFactId?: string;
-}
-export interface WorkflowSemanticAcceptance {
-    status: "passed" | "needs_attention";
-    passed: number;
-    total: number;
-    criteria: Array<{
-        id: string;
-        description: string;
-        status: "passed" | "failed" | "unverified";
-        evidence: string;
-        intentFactId?: string;
-    }>;
-    /** Active conversational intent facts and whether a deterministic criterion supplied evidence. */
-    intentCoverage: Array<{
-        factId: string;
-        statement: string;
-        status: "verified" | "failed" | "unverified";
-        evidence: string;
-    }>;
-}
-/** Flow-level semantic checks are evidence, not a save/finish hard gate. */
-export declare function assessWorkflowSemantics(input: {
-    def: WorkflowDef;
-    trigger?: TriggerDef | null;
-    criteria?: WorkflowSemanticCriterion[];
-    catalog?: CapabilityEntry[];
-    aliases?: Record<string, string>;
-    intentContract?: WorkflowIntentContract;
-}): WorkflowSemanticAcceptance;

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

@@ -1,22 +0,0 @@
-/**
- * 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-audit-store.d.ts

@@ -1,31 +0,0 @@
-/**
- * Workflow audit log (IT-12, spec D38): WHO did WHAT to WHICH workflow WHEN —
- * configuration/lifecycle changes only. Runs are deliberately NOT duplicated here:
- * WorkflowRunHistoryStore is already the complete run audit (trigger/timing/status/per-node);
- * a timeline UI merges both sources.
- *
- * Storage: append-only JSONL at `<project>/.qlogicagent/workflows/audit.jsonl` (project-level
- * single file — the natural unit for a cross-workflow timeline). Entries are never rewritten.
- */
-export interface WorkflowAuditEntry {
-    ts: string;
-    /** Owning user id (resolveActiveOwnerUserId) at the time of the action. */
-    actor: string;
-    /** e.g. created / updated / patched / activated / deactivated / published / archived /
-     *  reverted / deleted / imported / duplicated / permissionGranted / publishedToHub */
-    action: string;
-    workflowId: string;
-    detail?: Record<string, unknown>;
-}
-export declare class WorkflowAuditStore {
-    private readonly file;
-    /** `rootDir` = the project's workflows dir (same root the WorkflowStore uses). */
-    constructor(rootDir: string);
-    /**
-     * Append one entry. Failures are LOUD on stderr but never break the business write that
-     * triggered them (an audit-log disk error must not corrupt a successful state change).
-     */
-    append(entry: WorkflowAuditEntry): void;
-    /** Newest-first entries, optionally filtered to one workflow. Malformed lines are skipped loud. */
-    list(workflowId?: string, limit?: number): WorkflowAuditEntry[];
-}

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

@@ -1,74 +0,0 @@
-import type { CapabilityEntry } from "./capability-catalog.js";
-import type { WorkflowDef } from "./node-schema.js";
-import type { TriggerDef, WorkflowPatch } from "./workflow-patch.js";
-export type WorkflowAuthoringOperation = {
-    op: "add";
-    key: string;
-    capabilityId: string;
-    name?: string;
-    params?: Record<string, unknown>;
-} | {
-    op: "insert_after";
-    after: string;
-    key: string;
-    capabilityId: string;
-    name?: string;
-    params?: Record<string, unknown>;
-} | {
-    op: "replace_capability";
-    nodeId: string;
-    capabilityId: string;
-    name?: string;
-    params?: Record<string, unknown>;
-} | {
-    op: "update";
-    nodeId: string;
-    params: Record<string, unknown>;
-} | {
-    op: "rename";
-    nodeId: string;
-    name: string;
-} | {
-    op: "remove";
-    nodeId: string;
-} | {
-    op: "connect";
-    from: string;
-    to: string;
-    fromPort?: string;
-    toPort?: string;
-} | {
-    op: "connect_path";
-    nodes: string[];
-} | {
-    op: "disconnect";
-    from: string;
-    to: string;
-    fromPort?: string;
-} | {
-    op: "set_trigger";
-    trigger: TriggerDef;
-} | {
-    op: "set_node_options";
-    nodeId: string;
-    retry?: {
-        maxTries: number;
-        backoffMs?: number;
-    } | null;
-    timeoutMs?: number | null;
-    onError?: "stop" | "continue" | "errorPort" | null;
-};
-export interface CompiledWorkflowOperations {
-    patch: WorkflowPatch[];
-    aliasToNodeId: Record<string, string>;
-}
-/**
- * Compile the Agent's bounded authoring operations into the canonical WorkflowPatch protocol.
- * Node kinds, capability references, parameter templates and collision-free ids are Host/catalog
- * derived rather than freehand graph JSON.
- */
-export declare function compileWorkflowOperations(input: {
-    operations: WorkflowAuthoringOperation[];
-    current: WorkflowDef;
-    catalog: CapabilityEntry[];
-}): CompiledWorkflowOperations;

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

@@ -1,51 +0,0 @@
-/**
- * Canonical portable Workflow bundle shared by export, import, duplicate, Hub publish,
- * and Hub apply. Bundles contain graph structure and capability references only. Runtime
- * authentication remains owned by MCP and Provider modules and is never serialized here.
- */
-import { type WorkflowDef } from "./node-schema.js";
-import type { TriggerDef } from "./workflow-trigger.js";
-import type { ConcurrencyPolicy, WorkflowRecord } from "./workflow-store.js";
-import { type WorkflowTemplateSetupManifest } from "./workflow-template-setup.js";
-export declare const WORKFLOW_BUNDLE_SCHEMA_VERSION = 3;
-export interface CapabilityRequirement {
-    category: "agent" | "mcp" | "memory" | "channel";
-    kind: string;
-    /** Concrete capability reference, such as an Agent id or MCP plugin/tool id. */
-    ref: string;
-    /** Human-readable label shown in the apply checklist. */
-    label: string;
-    nodeIds: string[];
-}
-export interface WorkflowBundle {
-    schemaVersion: typeof WORKFLOW_BUNDLE_SCHEMA_VERSION;
-    name: string;
-    description?: string;
-    def: WorkflowDef;
-    trigger?: TriggerDef;
-    concurrency?: ConcurrencyPolicy;
-    requires: CapabilityRequirement[];
-    /** Optional centralized setup form. Values and credentials are never serialized. */
-    setup?: WorkflowTemplateSetupManifest;
-    meta?: {
-        author?: string;
-        tags?: string[];
-        category?: string;
-        version?: string;
-        source?: "native" | "n8n";
-    };
-}
-/** Derive capability requirements from canonical Agent attachments and Action nodes. */
-export declare function deriveRequirements(def: WorkflowDef): CapabilityRequirement[];
-/** Serialize a stored record into the canonical, credential-free bundle. */
-export declare function toWorkflowBundle(record: WorkflowRecord): WorkflowBundle;
-export interface ParsedBundle {
-    name: string;
-    def: WorkflowDef;
-    trigger?: TriggerDef;
-    concurrency?: ConcurrencyPolicy;
-    requires: CapabilityRequirement[];
-    setup?: WorkflowTemplateSetupManifest;
-}
-/** Parse and validate an incoming canonical bundle. */
-export declare function fromWorkflowBundle(payload: unknown): ParsedBundle;

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

@@ -1,237 +0,0 @@
-/**
- * Workflow Controller: reusable automation lifecycle and execution engine.
- *
- * Runtime's Gateway Host owns and constructs this controller with a project-scoped WorkflowStore.
- * The qlogicagent executable publishes the engine but never constructs a Workflow owner.
- * 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. Each trigger gets a fresh runtime/cache;
- *                   only pause/resume of the SAME run reuses runtime state.
- *   - "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 { RunCheckpoint } from "./run-checkpoint-store.js";
-import { type RunResult, type 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";
-import { type WorkflowTemplateSetupManifest, type WorkflowTemplateSetupState } from "./workflow-template-setup.js";
-import { type WorkflowRunHistoryStore } from "./run-history-store.js";
-export interface TriggerEvent {
-    type: WorkflowTriggerKind;
-    payload?: Record<string, unknown>;
-}
-export interface WorkflowRunStarted {
-    workflowId: string;
-    runId: string;
-    triggerType: WorkflowTriggerKind;
-}
-/**
- * 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 {
-    /** The workflow record id (so the runtime factory can tag per-node status notifications). */
-    workflowId: string;
-    /** Stable id for this run, used by history, checkpointing, pause/resume, and cancellation. */
-    runId: string;
-    type: WorkflowTriggerKind;
-    payload?: Record<string, unknown>;
-    /** Cancellation propagated to the runtime and host-backed node executors. */
-    signal?: AbortSignal;
-    /** The record's unattended capability grant at run start (D30; feeds the permission gate). */
-    permissionScope?: WorkflowRecord["permissionScope"];
-    /**
-     * R5 媒体工作室(D44):跨 run 内容寻址缓存 —— 本 run 从工作流级共享 checkpoint seed,
-     * 完成后保留(不清),下次"改参数只重跑下游"(ComfyUI 语义:未变节点命中缓存被跳过)。
-     * 默认关:自动化的副作用节点(发消息/HTTP POST)绝不能因"没变"被静默跳过;
-     * 工作室画布的"运行"显式带上(纯数据流面,跳过未变工序正是期望)。
-     */
-    reuseCache?: boolean;
-}
-/** Per-node lifecycle status surfaced for live canvas coloring (not durable; fire-and-forget). */
-export type NodeRunStatus = "running" | "completed" | "failed";
-/** 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" | "canceled";
-    /** Absent when status === "skipped" (a busy run under the "skip" policy). */
-    result?: RunResult;
-    /** Durable run-history id (present when a run-history store is wired). */
-    runId?: string;
-}
-export interface CreateInput {
-    id: string;
-    name: string;
-    def: WorkflowDef;
-    concurrency?: ConcurrencyPolicy;
-    active?: boolean;
-    /** Owning user (D38); the handler stamps resolveActiveOwnerUserId(). */
-    owner?: string;
-    setup?: WorkflowTemplateSetupManifest;
-    setupState?: WorkflowTemplateSetupState;
-}
-/** 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;
-    /** Optional durable run-history recorder. Wired here (not the handler) so every
-     *  trigger path — manual RPC, cron scheduler, IM, webhook — is captured alike. */
-    private readonly runHistory?;
-    private readonly slots;
-    private readonly activeRuns;
-    private readonly activeRunIdsByWorkflow;
-    private readonly suppressedHistoryRunIds;
-    constructor(store: WorkflowStore, runtimeFactory: RuntimeFactory, 
-    /** Optional durable run-history recorder. Wired here (not the handler) so every
-     *  trigger path — manual RPC, cron scheduler, IM, webhook — is captured alike. */
-    runHistory?: WorkflowRunHistoryStore | undefined);
-    create(input: CreateInput): Promise<WorkflowRecord>;
-    update(id: string, patch: Partial<Pick<WorkflowRecord, "name" | "def" | "concurrency" | "active" | "permissionScope" | "setup" | "setupState">>): Promise<WorkflowRecord>;
-    /** Apply all template answers to their node/trigger bindings in one CAS-protected revision. */
-    configureTemplate(id: string, input: {
-        baseRev: number;
-        values: Record<string, unknown>;
-    }): Promise<PatchOutcome & {
-        missingRequired?: string[];
-    }>;
-    setActive(id: string, active: boolean): Promise<WorkflowRecord>;
-    /**
-     * Publish (D31): snapshot the current draft (`def`) as the version triggers execute.
-     * Editing the draft afterwards never touches the running version until the next publish.
-     */
-    publish(id: string): Promise<WorkflowRecord>;
-    /** Archive (D31): keep the data, kill the lifecycle (deactivates; activation/publish refuse). */
-    archive(id: string, archived: boolean): Promise<WorkflowRecord>;
-    /**
-     * Revert a workflow to a stored revision snapshot (undo 基座). Git-revert semantics:
-     * the snapshot's def/name/trigger are re-applied as a NEW revision (rev bumps), so
-     * history stays forward-only and optimistic-concurrency baseRev checks keep working.
-     * fail-loud: unknown id or pruned/absent revision throws.
-     */
-    revertTo(id: string, rev: number): Promise<WorkflowRecord>;
-    /**
-     * Import an n8n workflow JSON into the single store. Native mappings stay native; compatible
-     * installed ecosystem nodes are resolved by the Host, while unsupported nodes remain explicit
-     * fail-loud placeholders. Every graph still passes the same canonical write validation.
-     */
-    importN8n(id: string, json: string | unknown, opts?: {
-        concurrency?: ConcurrencyPolicy;
-        owner?: string;
-    }): Promise<{
-        record: WorkflowRecord;
-        report: import("./n8n-import.js").N8nConversionReport;
-    }>;
-    /** 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 planning context (spec §B / §A `get`). Fail-loud on unknown id.
-     * Runtime Host supplies the authoritative record; stateless planning may use this rendering to
-     * propose 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, opts?: {
-        recordHistory?: boolean;
-        reuseCache?: boolean;
-        /** Host-only crash recovery: preserve the original run identity and history row. */
-        recoverRunId?: string;
-        onStarted?: (run: WorkflowRunStarted) => void | Promise<void>;
-    }): Promise<RunOutcome>;
-    /**
-     * Wrap a run with durable history recording (when wired). The running checkpoint is the
-     * publication barrier for lifecycle observers, and terminal history is fail-loud.
-     */
-    private recordRun;
-    /** Cooperatively pause the in-flight run; it suspends before the next node (cache retained). */
-    pause(id: string, opts?: {
-        runId?: 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?: {
-        runId?: string;
-        extraBudget?: {
-            executions?: number;
-            durationMs?: number;
-        };
-    }): Promise<RunOutcome>;
-    cancelRun(id: string, opts?: {
-        runId?: string;
-        reason?: string;
-    }): Promise<RunOutcome>;
-    delete(id: string): Promise<void>;
-    /** Active workflows whose triggers the gateway should re-register after restart (spec §B4). */
-    listActive(): Promise<WorkflowRecord[]>;
-    private slotFor;
-    private registerActiveRun;
-    private unregisterActiveRun;
-    private requireActiveRun;
-    private finishRunHistory;
-    /**
-     * 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;
-    private startTrackedRuntime;
-}
-/**
- * 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[];
-    /** Optional durable cache for crash/restart replay, keyed by workflow id + run id. */
-    checkpoint?: (workflowId: string, runId: string) => RunCheckpoint | undefined;
-    now?: () => Date;
-    /** Per-node lifecycle for live canvas coloring; workflowId comes from the run ctx. */
-    emitNodeStatus?: (workflowId: string, nodeId: string, status: NodeRunStatus, error?: string) => void;
-}): RuntimeFactory;

package/dist/types/orchestration/workflow/workflow-edit-context.d.ts

@@ -1,46 +0,0 @@
-import type { CapabilityEntry } from "./capability-catalog.js";
-import type { WorkflowDef, WorkflowNodeDef } from "./node-schema.js";
-import type { TriggerDef } from "./workflow-patch.js";
-export interface WorkflowEditContextCapsule {
-    workflowId: string;
-    trigger?: TriggerDef | null;
-    selectedNodeIds: string[];
-    nodes: WorkflowNodeDef[];
-    edges: WorkflowDef["edges"];
-    omittedNodeCount: number;
-    lineage: Record<string, {
-        upstream: Array<{
-            nodeId: string;
-            name?: string;
-            fields: string[];
-            expressionExamples: string[];
-        }>;
-    }>;
-    latestRun?: {
-        status: string;
-        failedNodeId?: string;
-        error?: string;
-        nodeEvidence: Array<{
-            nodeId: string;
-            preview?: string;
-            error?: string;
-        }>;
-    };
-}
-export interface WorkflowRunEvidence {
-    status: string;
-    failedNodeId?: string;
-    error?: string;
-    nodes?: Record<string, {
-        preview?: string;
-        error?: string;
-    }>;
-}
-export declare function buildWorkflowEditContextCapsule(input: {
-    def: WorkflowDef;
-    trigger?: TriggerDef | null;
-    scope?: string[];
-    catalog?: CapabilityEntry[];
-    latestRun?: WorkflowRunEvidence;
-    maxNodes?: number;
-}): WorkflowEditContextCapsule;

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

@@ -1,28 +0,0 @@
-/**
- * Workflow run-error classification (spec R6 / D49 / AI-5).
- *
- * Turns a raw thrown Error message into a human-readable, classified WorkflowError so the canvas can
- * show 人话 (never a stack) + the right next-step buttons (0 死端). Pure & deterministic — unit
- * tested. The executors throw plain Error(message); this maps those messages to a class + 中文说明.
- */
-export type WorkflowErrorClass = "user" | "capability" | "network" | "system";
-/** Next-step buttons the canvas offers for an error (0 死端 — every failure has a way forward). */
-export type WorkflowErrorAction = "ai_fix" | "rerun_node" | "rerun_all" | "swap_capability";
-export interface WorkflowError {
-    class: WorkflowErrorClass;
-    /** Plain-language Chinese explanation (NO stack trace). */
-    message: string;
-    /** What to do about it, in one line. */
-    hint?: string;
-    /** Ordered next-step actions for the UI (first = primary). */
-    actions: WorkflowErrorAction[];
-    /** Truncated raw message, for the advanced/debug view only. */
-    detail?: string;
-}
-/**
- * Classify a node failure. `raw` is the thrown error's message; `opts.nodeKind` refines wording.
- * Order matters: credential/auth and capability checks run before the generic "param" check.
- */
-export declare function classifyWorkflowError(raw: string, opts?: {
-    nodeKind?: string;
-}): WorkflowError;