qlogicagent 2.20.2 → 2.20.4

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

@@ -22,6 +22,12 @@ 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;
@@ -33,7 +39,11 @@ export interface RunNodeRecord {
     attempts?: number;
     cacheHit?: boolean;
     /** Per-node disposition; "failed" with a surviving run = onError errorPort/continue (D32). */
-    nodeStatus?: "completed" | "failed";
+    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;
 }
@@ -53,21 +63,41 @@ export interface RunHistoryEntry {
     /** nodeId → output record. Present once the run settles (not while running). */
     nodes?: Record<string, RunNodeRecord>;
 }
-/** Summary row for list views — full node outputs stay behind get(). */
+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">): Promise<void>;
+    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

@@ -0,0 +1,65 @@
+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/workflow-authoring.d.ts

@@ -0,0 +1,74 @@
+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

@@ -6,6 +6,7 @@
 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";
@@ -24,6 +25,8 @@ export interface WorkflowBundle {
     trigger?: TriggerDef;
     concurrency?: ConcurrencyPolicy;
     requires: CapabilityRequirement[];
+    /** Optional centralized setup form. Values and credentials are never serialized. */
+    setup?: WorkflowTemplateSetupManifest;
     meta?: {
         author?: string;
         tags?: string[];
@@ -42,6 +45,7 @@ export interface ParsedBundle {
     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

@@ -25,6 +25,7 @@ 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;
@@ -78,6 +79,8 @@ export interface CreateInput {
     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 = {
@@ -105,7 +108,14 @@ export declare class WorkflowController {
      *  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">>): 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.
@@ -122,9 +132,9 @@ export declare class WorkflowController {
      */
     revertTo(id: string, rev: number): 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.
+     * 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;
@@ -156,6 +166,8 @@ export declare class WorkflowController {
     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>;
     /**

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

@@ -0,0 +1,46 @@
+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-intent-contract.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Conversation-owned Workflow intent ledger.
+ *
+ * Deliberately not an acceptance gate: it has no ready/complete/pass field and is never consulted
+ * to decide whether a proposal may be saved or whether an Agent turn may finish. It preserves
+ * exact user observations plus a revisable interpretation so incomplete conversations work.
+ */
+export interface WorkflowIntentObservation {
+    id: string;
+    sequence: number;
+    text: string;
+}
+export interface WorkflowIntentFact {
+    id: string;
+    statement: string;
+    confidence: "explicit" | "inferred";
+    sourceObservationIds: string[];
+    status: "active" | "superseded";
+}
+export interface WorkflowIntentQuestion {
+    id: string;
+    question: string;
+    sourceObservationIds: string[];
+    status: "open" | "resolved";
+}
+export interface WorkflowIntentContract {
+    revision: number;
+    observations: WorkflowIntentObservation[];
+    facts: WorkflowIntentFact[];
+    openQuestions: WorkflowIntentQuestion[];
+    diagnostics: string[];
+}
+export interface WorkflowIntentDelta {
+    upsertFacts?: Array<{
+        id: string;
+        statement: string;
+        confidence: "explicit" | "inferred";
+        sourceObservationIds: string[];
+    }>;
+    supersedeFactIds?: string[];
+    upsertQuestions?: Array<{
+        id: string;
+        question: string;
+        sourceObservationIds: string[];
+    }>;
+    resolveQuestionIds?: string[];
+}
+export declare function evolveWorkflowIntentContract(input: {
+    previous: WorkflowIntentContract | null | undefined;
+    newTurns: Array<{
+        sequence: number;
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    delta?: WorkflowIntentDelta | null;
+}): WorkflowIntentContract;

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

@@ -91,6 +91,13 @@ export interface PatchEnvelope {
 export interface ApplyResult {
     target: PatchTarget;
     applied: WorkflowPatch[];
+    /** Non-blocking facts about pre-existing defects outside a scoped edit. */
+    diagnostics: WorkflowPatchDiagnostic[];
+}
+export interface WorkflowPatchDiagnostic {
+    classification: "preexisting";
+    nodeId: string;
+    message: string;
 }
 /** Thrown when a patch is rejected. `errors` is the ordered list of reasons (for self-correction). */
 export declare class PatchError extends Error {

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

@@ -82,6 +82,8 @@ export interface WorkflowRuntimeOptions {
     trigger?: Record<string, unknown>;
     /** This run's trigger KIND (manual/schedule/…) — exposed on ExecutorContext for IT-7b audits. */
     triggerKind?: string;
+    /** Durable run identity exposed to Host-backed node executors. */
+    runId?: string;
     log?: {
         info(m: string): void;
         warn(m: string): void;
@@ -108,6 +110,7 @@ export declare class WorkflowRuntime {
     private readonly now;
     private readonly trigger?;
     private readonly triggerKind?;
+    private readonly runId?;
     private readonly log?;
     private readonly host?;
     private readonly abortController?;
@@ -115,6 +118,8 @@ export declare class WorkflowRuntime {
     private readonly checkpoint?;
     private readonly preserveCheckpoint;
     private readonly onNodeStatus?;
+    /** Serializes snapshots so an older slow write cannot land after a newer parallel-node write. */
+    private checkpointWriteChain;
     private dag;
     private readonly nodeDefs;
     private readonly nodeOutputs;

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

@@ -28,6 +28,13 @@ export declare const systemClock: SchedulerClock;
 export interface SchedulerDeps {
     controller: WorkflowController;
     clock?: SchedulerClock;
+    /**
+     * Product-level timezone for legacy schedule records that predate an explicit timezone.
+     * The reusable engine remains UTC by default; desktop hosts should pass the user's system zone.
+     */
+    defaultTimezone?: string;
+    /** Latest durable scheduled-run start, used to detect one missed slot after a cold restart. */
+    getLastScheduledAt?: (workflowId: string) => Promise<number | undefined>;
     /**
      * Surfaces an error from a timer-driven (cron) run, which has no caller to throw back to.
      * Required so a failed unattended run is never silently swallowed (§1.5 fail-loud). Caller-driven
@@ -48,6 +55,8 @@ export interface SchedulerDeps {
     onTriggerDropped?: (workflowId: string, triggerType: string, detail: {
         sinceLastMs: number;
         minIntervalMs: number;
+        reason?: "rate-limit" | "misfire";
+        scheduledAt?: number;
     }) => void;
 }
 export declare class WorkflowScheduler {
@@ -57,6 +66,8 @@ export declare class WorkflowScheduler {
     private readonly onRunStarted?;
     private readonly onRunCompleted?;
     private readonly onRunFailed?;
+    private readonly defaultTimezone;
+    private readonly getLastScheduledAt?;
     /** Every registered workflow's trigger, keyed by id (the single source for lookups). */
     private readonly triggers;
     /** Active cron arms keyed by workflow id. */

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

@@ -9,6 +9,7 @@
  */
 import type { WorkflowDef } from "./node-schema.js";
 import type { TriggerDef } from "./workflow-patch.js";
+import type { WorkflowTemplateSetupManifest, WorkflowTemplateSetupState } from "./workflow-template-setup.js";
 /** What to do when a workflow is triggered while a previous run is still in-flight (spec §B5). */
 export type ConcurrencyPolicy = "queue" | "skip" | "parallel";
 export interface WorkflowRecord {
@@ -22,6 +23,10 @@ export interface WorkflowRecord {
     concurrency: ConcurrencyPolicy;
     /** The workflow's trigger (set via a WorkflowPatch set_trigger op; spec §C/D7). */
     trigger?: TriggerDef | null;
+    /** Portable, credential-free inputs shown in the import/template setup panel. */
+    setup?: WorkflowTemplateSetupManifest;
+    /** Non-secret answers and opaque connection references applied from `setup`. */
+    setupState?: WorkflowTemplateSetupState;
     /**
      * Unattended-run capability grant (spec D30, IT-7): sensitive node kinds this workflow may
      * execute under unattended triggers (schedule/im/webhook). Granted explicitly by the owner

package/dist/types/orchestration/workflow/workflow-template-setup.d.ts

@@ -0,0 +1,65 @@
+import type { WorkflowDef } from "./node-schema.js";
+import type { TriggerDef } from "./workflow-trigger.js";
+export type WorkflowTemplateSetupValue = string | number | boolean;
+export interface WorkflowTemplateSetupOption {
+    label: string;
+    value: string;
+}
+export interface WorkflowTemplateSetupField {
+    id: string;
+    label: string;
+    description?: string;
+    group?: string;
+    type: "text" | "textarea" | "url" | "number" | "boolean" | "select" | "connection";
+    required?: boolean;
+    placeholder?: string;
+    defaultValue?: WorkflowTemplateSetupValue;
+    options?: WorkflowTemplateSetupOption[];
+    /** Capability/provider family used to filter installed connections. */
+    connectionType?: string;
+}
+export interface WorkflowTemplateSetupBinding {
+    fieldId: string;
+    target: {
+        kind: "node";
+        nodeId: string;
+        path: string;
+    } | {
+        kind: "trigger";
+        path: string;
+    };
+}
+export interface WorkflowTemplateSetupManifest {
+    version: 1;
+    title?: string;
+    description?: string;
+    fields: WorkflowTemplateSetupField[];
+    bindings: WorkflowTemplateSetupBinding[];
+}
+export interface WorkflowTemplateSetupState {
+    values: Record<string, WorkflowTemplateSetupValue>;
+    updatedAt?: string;
+    completedAt?: string;
+}
+export interface WorkflowTemplateSetupProjection {
+    manifest: WorkflowTemplateSetupManifest;
+    values: Record<string, WorkflowTemplateSetupValue>;
+    status: "pending" | "complete";
+    missingRequired: string[];
+}
+export declare function validateWorkflowTemplateSetup(value: unknown, def: WorkflowDef): WorkflowTemplateSetupManifest;
+export declare function projectWorkflowTemplateSetup(manifest: WorkflowTemplateSetupManifest, state?: WorkflowTemplateSetupState): WorkflowTemplateSetupProjection;
+export declare function applyWorkflowTemplateSetup(definition: WorkflowDef, trigger: TriggerDef | null | undefined, manifest: WorkflowTemplateSetupManifest, previous: WorkflowTemplateSetupState | undefined, input: Record<string, unknown>, now?: string): {
+    def: WorkflowDef;
+    trigger?: TriggerDef | null;
+    state: WorkflowTemplateSetupState;
+    missingRequired: string[];
+};
+/**
+ * Reset every setup-bound destination before a workflow leaves the local Host.
+ * The manifest travels with the bundle; user answers and opaque connection ids do not.
+ */
+export declare function resetWorkflowTemplateSetupBindings(definition: WorkflowDef, trigger: TriggerDef | null | undefined, manifest: WorkflowTemplateSetupManifest): {
+    def: WorkflowDef;
+    trigger?: TriggerDef | null;
+};

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

@@ -4,6 +4,10 @@ export type TriggerDef = {
 } | {
     type: "schedule";
     cron: string;
+    /** IANA timezone used to interpret the cron wall clock. Missing legacy values remain UTC. */
+    timezone?: string;
+    /** Desktop sleep/wake behavior. A late timer never replays every missed slot. */
+    misfirePolicy?: "run-once" | "skip";
 } | {
     type: "im-message";
     channel: string;