qlogicagent 2.13.5 → 2.13.7

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

@@ -1,111 +0,0 @@
-/**
- * In-process workflow trigger scheduler (plan M3 trigger layer).
- *
- * Architecture note: scheduling lives INSIDE qlogicagent, not the gateway. This mirrors the
- * established precedent — the idle "dream" timer was deliberately moved out of the openclaw gateway
- * into qlogicagent so the Agent owns its own timed lifecycle ("Agent 是唯一状态拥有者"). The gateway
- * remains a pure relay: it terminates external ingress (webhook HTTP, inbound IM) and forwards those
- * events here via `onWebhook` / `onImMessage`; the cron clock and the run decision are the Agent's.
- *
- * The scheduler is the consumer of WorkflowController: on `start()` it loads every active workflow
- * (`listActive`, spec §B4 restart re-registration) and arms a timer per `schedule` trigger; on fire
- * it calls `controller.run(id, { type: "schedule" })`. Webhook / IM / manual triggers are
- * caller-driven (the gateway relay or the agent invokes the matching method). Concurrency,
- * budgeting, and permission gating all live in `controller.run` — the scheduler only decides WHEN.
- *
- * Determinism: the clock (now + timers) is injected, so tests pin time exactly and far-future cron
- * delays are handled by chunked re-arming (Node's setTimeout caps at ~24.8 days).
- */
-import type { WorkflowController, RunOutcome } from "./workflow-controller.js";
-export type TimerHandle = unknown;
-/** Injectable clock + timer surface so the scheduler is fully deterministic under test. */
-export interface SchedulerClock {
-    now(): number;
-    setTimer(fn: () => void, delayMs: number): TimerHandle;
-    clearTimer(handle: TimerHandle): void;
-}
-/** Default clock backed by the real system time and Node timers. */
-export declare const systemClock: SchedulerClock;
-export interface SchedulerDeps {
-    controller: WorkflowController;
-    clock?: SchedulerClock;
-    /**
-     * 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
-     * triggers (webhook/IM/manual) propagate their errors to the caller instead.
-     */
-    onError: (err: unknown, workflowId: string) => void;
-    onRunStarted?: (workflowId: string, triggerType: string) => void;
-    onRunCompleted?: (outcome: RunOutcome, triggerType: string) => void;
-    onRunFailed?: (workflowId: string, triggerType: string, err: unknown) => void;
-    /**
-     * Trigger rate-limit (D32/§B5 防洪): minimum ms between UNATTENDED fires (webhook/IM/cron) of
-     * the same workflow. A fire inside the window is DROPPED — loudly, via onTriggerDropped (dead
-     * letter), never silently. Manual/intent (attended) fires are exempt. Default 0 (off) — the
-     * production assembly (ensureWorkflowRoot) opts in explicitly; rate policy is the host's call.
-     */
-    minTriggerIntervalMs?: number;
-    /** Dead-letter surface for rate-limited drops. Required when minTriggerIntervalMs > 0. */
-    onTriggerDropped?: (workflowId: string, triggerType: string, detail: {
-        sinceLastMs: number;
-        minIntervalMs: number;
-    }) => void;
-}
-export declare class WorkflowScheduler {
-    private readonly controller;
-    private readonly clock;
-    private readonly onError;
-    private readonly onRunStarted?;
-    private readonly onRunCompleted?;
-    private readonly onRunFailed?;
-    /** Every registered workflow's trigger, keyed by id (the single source for lookups). */
-    private readonly triggers;
-    /** Active cron arms keyed by workflow id. */
-    private readonly cronArms;
-    /** Last unattended fire per workflow (rate-limit window anchor, D32). */
-    private readonly lastFireAt;
-    private readonly minTriggerIntervalMs;
-    private readonly onTriggerDropped?;
-    private started;
-    constructor(deps: SchedulerDeps);
-    /** Load every active workflow and arm its trigger (spec §B4 restart re-registration). */
-    start(): Promise<void>;
-    /** Stop all timers and forget every registration. Idempotent. */
-    stop(): void;
-    /**
-     * Re-read a workflow and (re-)arm its trigger after a create/patch/setActive change. If the
-     * workflow no longer exists or is inactive it is unregistered. Active workflows are armed by
-     * their current trigger (manual ⇒ lookup-only, no timer).
-     */
-    refresh(id: string): Promise<void>;
-    /** Drop a workflow's registration and cancel any pending cron timer. */
-    unregister(id: string): void;
-    /** Workflow ids currently registered (for inspection/tests). */
-    registeredIds(): string[];
-    /** The epoch ms a scheduled workflow will next fire, or undefined if it has no cron arm. */
-    nextFireAt(id: string): number | undefined;
-    /**
-     * Deliver an external webhook hit. Runs every active workflow whose webhook trigger path equals
-     * `path`. Returns the outcomes (empty ⇒ no workflow matched, which the gateway maps to 404).
-     * Errors propagate to the caller (the HTTP handler), which is the fail-loud surface here.
-     */
-    onWebhook(path: string, payload?: Record<string, unknown>): Promise<RunOutcome[]>;
-    /**
-     * Deliver an inbound IM message. Runs every active workflow whose im-message trigger is on
-     * `channel` and whose optional `match` regex tests `text`. The message text + channel are merged
-     * into the run payload so downstream nodes can reference `$trigger`.
-     */
-    onImMessage(channel: string, text: string, payload?: Record<string, unknown>): Promise<RunOutcome[]>;
-    /** Manually trigger a single workflow (the agent's `workflow.run`). Errors propagate to caller. */
-    triggerManual(id: string, payload?: Record<string, unknown>): Promise<RunOutcome>;
-    private matchingIds;
-    private registerTrigger;
-    private armCron;
-    private fireCron;
-    /**
-     * Unattended-fire rate limit (D32): true ⇒ proceed (and anchor the window); false ⇒ DROPPED,
-     * surfaced via onTriggerDropped (dead letter) — never silent.
-     */
-    private passesRateLimit;
-    private runWithLifecycle;
-}

package/dist/orchestration/workflow/workflow-scheduler.js

@@ -1,230 +0,0 @@
-/**
- * In-process workflow trigger scheduler (plan M3 trigger layer).
- *
- * Architecture note: scheduling lives INSIDE qlogicagent, not the gateway. This mirrors the
- * established precedent — the idle "dream" timer was deliberately moved out of the openclaw gateway
- * into qlogicagent so the Agent owns its own timed lifecycle ("Agent 是唯一状态拥有者"). The gateway
- * remains a pure relay: it terminates external ingress (webhook HTTP, inbound IM) and forwards those
- * events here via `onWebhook` / `onImMessage`; the cron clock and the run decision are the Agent's.
- *
- * The scheduler is the consumer of WorkflowController: on `start()` it loads every active workflow
- * (`listActive`, spec §B4 restart re-registration) and arms a timer per `schedule` trigger; on fire
- * it calls `controller.run(id, { type: "schedule" })`. Webhook / IM / manual triggers are
- * caller-driven (the gateway relay or the agent invokes the matching method). Concurrency,
- * budgeting, and permission gating all live in `controller.run` — the scheduler only decides WHEN.
- *
- * Determinism: the clock (now + timers) is injected, so tests pin time exactly and far-future cron
- * delays are handled by chunked re-arming (Node's setTimeout caps at ~24.8 days).
- */
-import { nextCronTime } from "./cron-schedule.js";
-/** Default clock backed by the real system time and Node timers. */
-export const systemClock = {
-    now: () => Date.now(),
-    setTimer: (fn, delayMs) => setTimeout(fn, delayMs),
-    clearTimer: (handle) => clearTimeout(handle),
-};
-// Node's setTimeout truncates delays above 2^31-1 ms; chunk anything longer and re-arm.
-const MAX_TIMER_DELAY = 2_000_000_000;
-export class WorkflowScheduler {
-    controller;
-    clock;
-    onError;
-    onRunStarted;
-    onRunCompleted;
-    onRunFailed;
-    /** Every registered workflow's trigger, keyed by id (the single source for lookups). */
-    triggers = new Map();
-    /** Active cron arms keyed by workflow id. */
-    cronArms = new Map();
-    /** Last unattended fire per workflow (rate-limit window anchor, D32). */
-    lastFireAt = new Map();
-    minTriggerIntervalMs;
-    onTriggerDropped;
-    started = false;
-    constructor(deps) {
-        if (!deps.controller)
-            throw new Error("WorkflowScheduler requires a controller");
-        if (typeof deps.onError !== "function")
-            throw new Error("WorkflowScheduler requires an onError handler");
-        this.controller = deps.controller;
-        this.clock = deps.clock ?? systemClock;
-        this.onError = deps.onError;
-        this.onRunStarted = deps.onRunStarted;
-        this.onRunCompleted = deps.onRunCompleted;
-        this.onRunFailed = deps.onRunFailed;
-        this.minTriggerIntervalMs = deps.minTriggerIntervalMs ?? 0;
-        this.onTriggerDropped = deps.onTriggerDropped;
-        if (this.minTriggerIntervalMs > 0 && !this.onTriggerDropped) {
-            throw new Error("WorkflowScheduler: minTriggerIntervalMs > 0 requires onTriggerDropped (drops must never be silent, §1.5)");
-        }
-    }
-    /** Load every active workflow and arm its trigger (spec §B4 restart re-registration). */
-    async start() {
-        if (this.started)
-            throw new Error("WorkflowScheduler already started");
-        this.started = true;
-        const active = await this.controller.listActive();
-        for (const rec of active)
-            this.registerTrigger(rec.id, rec.trigger ?? { type: "manual" });
-    }
-    /** Stop all timers and forget every registration. Idempotent. */
-    stop() {
-        for (const arm of this.cronArms.values())
-            this.clock.clearTimer(arm.handle);
-        this.cronArms.clear();
-        this.triggers.clear();
-        this.started = false;
-    }
-    /**
-     * Re-read a workflow and (re-)arm its trigger after a create/patch/setActive change. If the
-     * workflow no longer exists or is inactive it is unregistered. Active workflows are armed by
-     * their current trigger (manual ⇒ lookup-only, no timer).
-     */
-    async refresh(id) {
-        let rec;
-        try {
-            rec = await this.controller.get(id);
-        }
-        catch {
-            this.unregister(id);
-            return;
-        }
-        if (!rec.active) {
-            this.unregister(id);
-            return;
-        }
-        this.registerTrigger(id, rec.trigger ?? { type: "manual" });
-    }
-    /** Drop a workflow's registration and cancel any pending cron timer. */
-    unregister(id) {
-        const arm = this.cronArms.get(id);
-        if (arm) {
-            this.clock.clearTimer(arm.handle);
-            this.cronArms.delete(id);
-        }
-        this.triggers.delete(id);
-    }
-    /** Workflow ids currently registered (for inspection/tests). */
-    registeredIds() {
-        return [...this.triggers.keys()];
-    }
-    /** The epoch ms a scheduled workflow will next fire, or undefined if it has no cron arm. */
-    nextFireAt(id) {
-        return this.cronArms.get(id)?.fireAt;
-    }
-    // ── caller-driven triggers (gateway relay / agent) ───────────
-    /**
-     * Deliver an external webhook hit. Runs every active workflow whose webhook trigger path equals
-     * `path`. Returns the outcomes (empty ⇒ no workflow matched, which the gateway maps to 404).
-     * Errors propagate to the caller (the HTTP handler), which is the fail-loud surface here.
-     */
-    async onWebhook(path, payload) {
-        const ids = this.matchingIds(t => t.type === "webhook" && t.path === path)
-            .filter(id => this.passesRateLimit(id, "webhook"));
-        return Promise.all(ids.map(id => this.runWithLifecycle(id, { type: "webhook", payload })));
-    }
-    /**
-     * Deliver an inbound IM message. Runs every active workflow whose im-message trigger is on
-     * `channel` and whose optional `match` regex tests `text`. The message text + channel are merged
-     * into the run payload so downstream nodes can reference `$trigger`.
-     */
-    async onImMessage(channel, text, payload) {
-        const ids = this.matchingIds(t => t.type === "im-message" && t.channel === channel && imMatches(t.match, text))
-            .filter(id => this.passesRateLimit(id, "im-message"));
-        const merged = { ...payload, channel, text };
-        return Promise.all(ids.map(id => this.runWithLifecycle(id, { type: "im-message", payload: merged })));
-    }
-    /** Manually trigger a single workflow (the agent's `workflow.run`). Errors propagate to caller. */
-    async triggerManual(id, payload) {
-        return this.runWithLifecycle(id, { type: "manual", payload });
-    }
-    // ── internals ────────────────────────────────────────────────
-    matchingIds(pred) {
-        const out = [];
-        for (const [id, t] of this.triggers)
-            if (pred(t))
-                out.push(id);
-        return out;
-    }
-    registerTrigger(id, trigger) {
-        // Replace any prior registration (cancels a stale cron arm) before re-arming.
-        this.unregister(id);
-        this.triggers.set(id, trigger);
-        if (trigger.type === "schedule") {
-            const fireAt = nextCronTime(trigger.cron, this.clock.now());
-            this.armCron(id, trigger.cron, fireAt);
-        }
-        // webhook / im-message / manual are lookup-driven — no timer to arm.
-    }
-    armCron(id, cron, fireAt) {
-        const delay = Math.max(0, fireAt - this.clock.now());
-        const arm = { cron, fireAt, handle: undefined };
-        if (delay > MAX_TIMER_DELAY) {
-            // Too far out for one timer: wake at the cap and re-arm toward the same fireAt.
-            arm.handle = this.clock.setTimer(() => {
-                const live = this.cronArms.get(id);
-                if (live !== arm)
-                    return; // superseded by refresh/unregister
-                this.armCron(id, cron, fireAt);
-            }, MAX_TIMER_DELAY);
-        }
-        else {
-            arm.handle = this.clock.setTimer(() => this.fireCron(id, arm), delay);
-        }
-        this.cronArms.set(id, arm);
-    }
-    fireCron(id, arm) {
-        if (this.cronArms.get(id) !== arm)
-            return; // superseded between scheduling and firing
-        // Re-arm for the next slot BEFORE running so a long run never delays the cadence.
-        let nextAt;
-        try {
-            nextAt = nextCronTime(arm.cron, arm.fireAt);
-        }
-        catch (err) {
-            this.cronArms.delete(id);
-            this.onError(err, id);
-            return;
-        }
-        this.armCron(id, arm.cron, nextAt);
-        // Rate-limit even cron (a misconfigured every-second cron is a self-DoS); drop is loud.
-        if (!this.passesRateLimit(id, "schedule"))
-            return;
-        // Fire the run; a timer-driven failure has no caller, so route it to onError.
-        this.runWithLifecycle(id, { type: "schedule" }).catch(err => this.onError(err, id));
-    }
-    /**
-     * Unattended-fire rate limit (D32): true ⇒ proceed (and anchor the window); false ⇒ DROPPED,
-     * surfaced via onTriggerDropped (dead letter) — never silent.
-     */
-    passesRateLimit(id, triggerType) {
-        if (this.minTriggerIntervalMs <= 0)
-            return true;
-        const now = this.clock.now();
-        const last = this.lastFireAt.get(id);
-        if (last !== undefined && now - last < this.minTriggerIntervalMs) {
-            this.onTriggerDropped?.(id, triggerType, { sinceLastMs: now - last, minIntervalMs: this.minTriggerIntervalMs });
-            return false;
-        }
-        this.lastFireAt.set(id, now);
-        return true;
-    }
-    async runWithLifecycle(id, trigger) {
-        this.onRunStarted?.(id, trigger.type);
-        try {
-            const outcome = await this.controller.run(id, trigger);
-            this.onRunCompleted?.(outcome, trigger.type);
-            return outcome;
-        }
-        catch (err) {
-            this.onRunFailed?.(id, trigger.type, err);
-            throw err;
-        }
-    }
-}
-/** True when the (optional, pre-validated) IM match regex accepts `text`; no match ⇒ always fires. */
-function imMatches(match, text) {
-    if (match === undefined)
-        return true;
-    return new RegExp(match).test(text);
-}

package/dist/orchestration/workflow/workflow-service.d.ts

@@ -1,14 +0,0 @@
-/**
- * Process-level WorkflowController singleton (single-track, D17 "one store / one engine").
- *
- * The ACP workflow-handler builds the fully-wired controller (real ExecutorHost: agent/tool/mcp)
- * and publishes it here. The agent-facing `workflow` tool resolves the same instance so authoring
- * (create/patch) and running share one engine + one store. When the engine has not been
- * initialized (e.g. a bare CLI tool turn before any ACP workflow call), callers that only need
- * authoring can fall back to a store-only controller; `run` fail-louds (no silent no-op).
- */
-import type { WorkflowController } from "./workflow-controller.js";
-/** Publish the fully-wired controller (called by ensureWorkflowController). */
-export declare function setWorkflowController(ctrl: WorkflowController): void;
-/** The live, run-capable controller, or null if the engine has not been initialized yet. */
-export declare function getWorkflowController(): WorkflowController | null;

package/dist/orchestration/workflow/workflow-service.js

@@ -1,18 +0,0 @@
-/**
- * Process-level WorkflowController singleton (single-track, D17 "one store / one engine").
- *
- * The ACP workflow-handler builds the fully-wired controller (real ExecutorHost: agent/tool/mcp)
- * and publishes it here. The agent-facing `workflow` tool resolves the same instance so authoring
- * (create/patch) and running share one engine + one store. When the engine has not been
- * initialized (e.g. a bare CLI tool turn before any ACP workflow call), callers that only need
- * authoring can fall back to a store-only controller; `run` fail-louds (no silent no-op).
- */
-let shared = null;
-/** Publish the fully-wired controller (called by ensureWorkflowController). */
-export function setWorkflowController(ctrl) {
-    shared = ctrl;
-}
-/** The live, run-capable controller, or null if the engine has not been initialized yet. */
-export function getWorkflowController() {
-    return shared;
-}

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

@@ -1,81 +0,0 @@
-/**
- * Workflow Store — persist workflow definitions + lifecycle state to disk (spec §B4).
- *
- * Stored at `<project>/.qlogicagent/workflows/<workflowId>/workflow.json`. Listing enumerates
- * subdirectories (mirrors product-persistence.ts). The store is the single source of truth for a
- * workflow's definition, its active flag, and its concurrency policy; the gateway re-registers
- * triggers for every active workflow on restart (spec §B4).
- *
- * fail-loud: missing id on save throws; load returns undefined only for a genuinely absent record.
- */
-import type { WorkflowDef } from "./node-schema.js";
-import type { TriggerDef } from "./workflow-patch.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 {
-    id: string;
-    name: string;
-    /** Owning user (llmrouter id via resolveActiveOwnerUserId, D38). Absent on legacy records. */
-    owner?: string;
-    def: WorkflowDef;
-    /** Active workflows have their triggers registered by the gateway (spec §B4). */
-    active: boolean;
-    concurrency: ConcurrencyPolicy;
-    /** The workflow's trigger (set via a WorkflowPatch set_trigger op; spec §C/D7). */
-    trigger?: TriggerDef | null;
-    /**
-     * 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
-     * at activation time; absent ⇒ unattended runs of sensitive kinds are denied by the gate.
-     */
-    permissionScope?: {
-        allowUnattendedKinds: string[];
-        grantedAt: string;
-    } | null;
-    /** The published (run-by-triggers) snapshot. Absent ⇒ never published ⇒ cannot activate. */
-    publishedDef?: WorkflowDef | null;
-    /** The draft rev that was published (UI: draft-ahead badge when rev > publishedRev). */
-    publishedRev?: number;
-    /** Archived workflows keep their data but cannot run or activate (D31 lifecycle). */
-    archived?: boolean;
-    /** Monotonic revision for optimistic concurrency (LWW); bumped on every patch (spec §C). */
-    rev: number;
-    createdAt: string;
-    updatedAt: string;
-}
-/** Root dir of all workflow records for a project (shared with the run-history store). */
-export declare function workflowsDir(cwd: string): string;
-/** Bounded def-revision history depth — enough for undo, small enough to never matter on disk. */
-export declare const MAX_REVISIONS = 20;
-/** Summary row for revision lists (full snapshot stays behind loadRevision). */
-export interface RevisionSummary {
-    rev: number;
-    updatedAt: string;
-    name: string;
-    nodeCount: number;
-}
-export declare class WorkflowStore {
-    private readonly cwd;
-    constructor(cwd: string);
-    save(record: WorkflowRecord): Promise<void>;
-    /**
-     * Persist a per-rev snapshot alongside the live record (undo/revert 基座).
-     * Keyed by rev: a meta-only update (same rev, e.g. setActive) overwrites its own
-     * snapshot; a patch (rev bump) appends a new one. Bounded to MAX_REVISIONS.
-     * fail-soft: snapshot/prune errors must never block the primary save.
-     */
-    private snapshotRevision;
-    /** Revision numbers, newest first. */
-    private revisionNumbers;
-    /** Newest-first revision summaries for the undo/history UI. */
-    listRevisions(id: string): Promise<RevisionSummary[]>;
-    /** Full record snapshot at a given rev (undefined when pruned/absent). */
-    loadRevision(id: string, rev: number): Promise<WorkflowRecord | undefined>;
-    load(id: string): Promise<WorkflowRecord | undefined>;
-    /** Load a record or throw (fail-loud lookup for callers that require existence). */
-    require(id: string): Promise<WorkflowRecord>;
-    list(): Promise<WorkflowRecord[]>;
-    /** Active workflows the gateway must re-register triggers for after a restart (spec §B4). */
-    listActive(): Promise<WorkflowRecord[]>;
-    delete(id: string): Promise<void>;
-}

package/dist/orchestration/workflow/workflow-store.js

@@ -1,123 +0,0 @@
-/**
- * Workflow Store — persist workflow definitions + lifecycle state to disk (spec §B4).
- *
- * Stored at `<project>/.qlogicagent/workflows/<workflowId>/workflow.json`. Listing enumerates
- * subdirectories (mirrors product-persistence.ts). The store is the single source of truth for a
- * workflow's definition, its active flag, and its concurrency policy; the gateway re-registers
- * triggers for every active workflow on restart (spec §B4).
- *
- * fail-loud: missing id on save throws; load returns undefined only for a genuinely absent record.
- */
-import { join } from "node:path";
-import { mkdir, readdir, rm } from "node:fs/promises";
-import { readJsonFile, writeJsonFile } from "../../runtime/infra/disk-storage.js";
-import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
-/** Root dir of all workflow records for a project (shared with the run-history store). */
-export function workflowsDir(cwd) {
-    return join(getDefaultPathService().getProjectAgentDir(cwd), "workflows");
-}
-function recordPath(id, cwd) {
-    return join(workflowsDir(cwd), id, "workflow.json");
-}
-function revisionsDir(id, cwd) {
-    return join(workflowsDir(cwd), id, "revisions");
-}
-/** Bounded def-revision history depth — enough for undo, small enough to never matter on disk. */
-export const MAX_REVISIONS = 20;
-export class WorkflowStore {
-    cwd;
-    constructor(cwd) {
-        this.cwd = cwd;
-        if (!cwd)
-            throw new Error("WorkflowStore requires a project cwd");
-    }
-    async save(record) {
-        if (!record.id)
-            throw new Error("WorkflowRecord.id is required");
-        const dir = join(workflowsDir(this.cwd), record.id);
-        await mkdir(dir, { recursive: true });
-        await writeJsonFile(recordPath(record.id, this.cwd), record);
-        await this.snapshotRevision(record);
-    }
-    /**
-     * Persist a per-rev snapshot alongside the live record (undo/revert 基座).
-     * Keyed by rev: a meta-only update (same rev, e.g. setActive) overwrites its own
-     * snapshot; a patch (rev bump) appends a new one. Bounded to MAX_REVISIONS.
-     * fail-soft: snapshot/prune errors must never block the primary save.
-     */
-    async snapshotRevision(record) {
-        try {
-            const dir = revisionsDir(record.id, this.cwd);
-            await mkdir(dir, { recursive: true });
-            await writeJsonFile(join(dir, `${record.rev}.json`), record);
-            const revs = await this.revisionNumbers(record.id);
-            for (const rev of revs.slice(MAX_REVISIONS)) {
-                await rm(join(dir, `${rev}.json`), { force: true });
-            }
-        }
-        catch {
-            // Revision history is best-effort; the live record save already succeeded.
-        }
-    }
-    /** Revision numbers, newest first. */
-    async revisionNumbers(id) {
-        let files;
-        try {
-            files = await readdir(revisionsDir(id, this.cwd));
-        }
-        catch {
-            return [];
-        }
-        return files
-            .map(f => Number(f.replace(/\.json$/, "")))
-            .filter(n => Number.isInteger(n) && n > 0)
-            .sort((a, b) => b - a);
-    }
-    /** Newest-first revision summaries for the undo/history UI. */
-    async listRevisions(id) {
-        const out = [];
-        for (const rev of await this.revisionNumbers(id)) {
-            const snap = await this.loadRevision(id, rev);
-            if (snap)
-                out.push({ rev, updatedAt: snap.updatedAt, name: snap.name, nodeCount: snap.def.nodes.length });
-        }
-        return out;
-    }
-    /** Full record snapshot at a given rev (undefined when pruned/absent). */
-    async loadRevision(id, rev) {
-        return readJsonFile(join(revisionsDir(id, this.cwd), `${rev}.json`));
-    }
-    async load(id) {
-        return readJsonFile(recordPath(id, this.cwd));
-    }
-    /** Load a record or throw (fail-loud lookup for callers that require existence). */
-    async require(id) {
-        const rec = await this.load(id);
-        if (!rec)
-            throw new Error(`Workflow "${id}" not found`);
-        return rec;
-    }
-    async list() {
-        let entries;
-        try {
-            entries = await readdir(workflowsDir(this.cwd));
-        }
-        catch {
-            return [];
-        }
-        const out = [];
-        for (const id of entries) {
-            const rec = await this.load(id);
-            if (rec)
-                out.push(rec);
-        }
-        return out;
-    }
-    /** Active workflows the gateway must re-register triggers for after a restart (spec §B4). */
-    async listActive() {
-        return (await this.list()).filter(r => r.active);
-    }
-    async delete(id) {
-        await rm(join(workflowsDir(this.cwd), id), { recursive: true, force: true });
-    }
-}

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

@@ -1,35 +0,0 @@
-/** Workflow trigger definitions shared by patching, validation, storage, and render helpers. */
-export type TriggerDef = {
-    type: "manual";
-} | {
-    type: "schedule";
-    cron: string;
-} | {
-    type: "im-message";
-    channel: string;
-    match?: string;
-} | {
-    type: "webhook";
-    path: string;
-} | {
-    type: "form";
-    fields: Array<{
-        key: string;
-        label?: string;
-        type?: "text" | "number" | "select";
-        options?: string[];
-        required?: boolean;
-    }>;
-} | {
-    type: "intent";
-    /** 触发短语(精确/归一化匹配),至少一条。 */
-    phrases: string[];
-    /** 别名(同样精确匹配)。 */
-    aliases?: string[];
-    /** 开启语义兜底(确定性未命中时一次 LLM 分类;有成本,默认关)。 */
-    semantic?: boolean;
-    /** 命中后是否弹确认(默认 true;关闭=说出即跑)。 */
-    confirm?: boolean;
-    /** 生效界面;缺省 = 欢迎页+对话页都生效。 */
-    surfaces?: ("welcome" | "chat")[];
-};

package/dist/orchestration/workflow/workflow-trigger.js

@@ -1 +0,0 @@
-export {};