openworkgraph 0.2.12

package/dist/execution-chains.js

@@ -0,0 +1,231 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { executionOrder, isTerminalRunStatus } from "./vendor/protocol/index.js";
+import { Runs } from './runs.js';
+import { Graphs } from './graphs.js';
+import { Resources } from './resources.js';
+import { atomic } from './persistence/database.js';
+import { canonicalJson } from './persistence/repositories.js';
+import { ServiceError } from './errors.js';
+/** Accepted runs are durable submissions. Only confirmed, dependency-ready runs enter the queue. */
+export class ExecutionChains {
+    runs;
+    graphs;
+    resources;
+    pumping = false;
+    stopped = false;
+    stop() { this.stopped = true; }
+    constructor(runs, graphs, resources) {
+        this.runs = runs;
+        this.graphs = graphs;
+        this.resources = resources;
+    }
+    get db() { return this.runs.db; }
+    histories(graph, nodeId, exclude) {
+        return this.db.prepare('SELECT id FROM runs WHERE project_id=? AND graph_id=? AND node_id=? ORDER BY sequence').all(graph.projectId, graph.graphId, nodeId).filter(row => row.id !== exclude).map(row => this.runs.get(String(row.id)));
+    }
+    plan(graph, targetId, exclude) {
+        const edges = graph.edges.filter(e => e.kind === 'execution');
+        if (!executionOrder(edges))
+            throw new ServiceError('INVALID_EDGE', '执行依赖存在环。');
+        if (graph.nodes.find(n => n.id === targetId)?.type !== 'execution')
+            throw new ServiceError('INVALID_REQUEST', '只有执行节点支持串联调度。');
+        const ids = new Set([targetId]), queue = [targetId];
+        for (let i = 0; i < queue.length; i++)
+            for (const e of edges)
+                if (e.targetId === queue[i] && !ids.has(e.sourceId)) {
+                    ids.add(e.sourceId);
+                    queue.push(e.sourceId);
+                }
+        const nodes = graph.nodes.filter(n => ids.has(n.id)).map(n => {
+            const history = this.histories(graph, n.id, exclude);
+            const content = n.content && typeof n.content === 'object' && !Array.isArray(n.content) ? n.content : {};
+            // Already submitted runs use their frozen prompt, not subsequent node edits.
+            const submitted = n.id === targetId && exclude || history.find(r => r.status === 'accepted' && ['manual', 'confirm'].includes(r.executionStart ?? ''))?.id;
+            const prompt = submitted ? this.runs.snapshot(submitted).prompt : content.prompt;
+            return { id: n.id, title: typeof content.title === 'string' ? content.title : n.id, required: n.id === targetId || !history.some(r => r.status === 'succeeded'), hasRun: history.some(r => r.status !== 'accepted'), missingPrompt: typeof prompt !== 'string' || !prompt.trim() };
+        });
+        const requiresConfirmation = nodes.some(n => n.hasRun) && nodes.length > 1;
+        return { targetId, executionRevision: graph.executionRevision, nodes, edges: edges.filter(e => ids.has(e.sourceId) && ids.has(e.targetId)), initialNodeIds: nodes.filter(n => n.required).map(n => n.id), requiresConfirmation };
+    }
+    forRun(id) { const run = this.runs.get(id); return this.plan(this.graphs.snapshot(run), run.nodeId, id); }
+    cancel(id, key, principal) {
+        this.runs.repo.idempotent(principal + ':chain.cancel:' + id, key, { id }, () => {
+            const target = this.runs.get(id);
+            const runtime = this.runs.runtime(id);
+            if (runtime.details.chainBatch !== id)
+                throw new ServiceError('INVALID_REQUEST', '请从本轮串联主任务停止整体调度。');
+            const members = this.db.prepare("SELECT r.id FROM runs r JOIN run_runtime rt ON rt.run_id=r.id WHERE r.project_id=? AND r.graph_id=? AND json_extract(rt.details,'$.chainBatch')=?").all(target.projectId, target.graphId, id);
+            this.setMode(id, runtime.details.executionStart, { chainStopRequested: true });
+            for (const member of members) {
+                const memberId = String(member.id);
+                if (isTerminalRunStatus(this.runs.get(memberId).status))
+                    continue;
+                this.runs.cancel(memberId, key, principal + ':chain:' + id);
+                this.runs.record(memberId, 'workflow', { message: '主任务已请求停止本轮串联调度。', targetRunId: id });
+            }
+            return { id };
+        });
+        return this.runs.get(id);
+    }
+    selection(plan, seeds) {
+        if (!Array.isArray(seeds) || seeds.length > plan.nodes.length || seeds.some(id => typeof id !== 'string' || !plan.nodes.some(n => n.id === id)))
+            throw new ServiceError('INVALID_REQUEST', '执行范围包含无关节点。');
+        const selected = new Set([...seeds, ...plan.nodes.filter(n => n.required).map(n => n.id)]);
+        const queue = [...selected];
+        for (let i = 0; i < queue.length; i++)
+            for (const e of plan.edges)
+                if (e.sourceId === queue[i] && !selected.has(e.targetId)) {
+                    selected.add(e.targetId);
+                    queue.push(e.targetId);
+                }
+        const order = executionOrder(plan.edges);
+        if (!order.includes(plan.targetId))
+            order.push(plan.targetId);
+        return order.filter(id => selected.has(id));
+    }
+    setMode(id, executionStart, extra = {}) {
+        const runtime = this.runs.runtime(id);
+        this.db.prepare('UPDATE run_runtime SET details=?,revision=revision+1 WHERE run_id=?').run(canonicalJson({ ...runtime.details, ...extra, executionStart: executionStart }), id);
+        const run = this.runs.get(id);
+        this.runs.repo.appendEvent({ eventId: randomUUID(), type: 'run.changed', projectId: run.projectId, graphId: run.graphId, entityId: id, revision: runtime.revision + 1, occurredAt: new Date().toISOString(), payload: run });
+    }
+    /** Prepare every missing run before entering the auth transaction. No partial batch on failure. */
+    async prepareMembers(graph, plan, selected, targetRunId, prepare) {
+        const missing = plan.nodes.filter(n => selected.includes(n.id) && n.missingPrompt);
+        if (missing.length)
+            throw new ServiceError('INPUT_BLOCKED', '请先填写以下节点的提示词：' + missing.map(n => n.title).join('、'));
+        const members = new Map();
+        const commits = new Map();
+        for (const id of selected) {
+            if (id === plan.targetId && targetRunId) {
+                members.set(id, targetRunId);
+                continue;
+            }
+            const active = this.histories(graph, id).find(r => !isTerminalRunStatus(r.status));
+            if (active) {
+                if (active.status !== 'accepted' || !['manual', 'confirm'].includes(active.executionStart ?? ''))
+                    throw new ServiceError('ACTIVE_RUN', '所选节点已在其他执行计划中运行。');
+                members.set(id, active.id);
+            }
+            else {
+                const node = graph.nodes.find(n => n.id === id);
+                const content = node.content && typeof node.content === 'object' && !Array.isArray(node.content) ? node.content : {};
+                commits.set(id, await prepare({ serviceId: graph.serviceId, projectId: graph.projectId, graphId: graph.graphId, nodeId: id, kind: 'execution', idempotencyKey: randomUUID(), expectedExecutionRevision: graph.executionRevision, ...(content.modelOverride ? { modelOverride: content.modelOverride } : {}) }));
+            }
+        }
+        const reused = new Map();
+        for (const e of plan.edges)
+            if (selected.includes(e.targetId) && !selected.includes(e.sourceId)) {
+                const success = this.histories(graph, e.sourceId).filter(r => r.status === 'succeeded').at(-1);
+                if (!success)
+                    throw new ServiceError('INPUT_BLOCKED', '前驱没有可复用的成功结果，请扩大执行范围。');
+                reused.set(e.sourceId, success.id);
+            }
+        return (principal, target) => {
+            const committedMembers = new Map(members);
+            if (this.graphs.snapshot(graph).executionRevision !== plan.executionRevision)
+                throw new ServiceError('REVISION_CONFLICT', '工作图已变化，请重新确认执行范围。');
+            if (target)
+                committedMembers.set(plan.targetId, target.id);
+            for (const [id, commit] of commits)
+                if (!committedMembers.has(id))
+                    committedMembers.set(id, commit(principal).id);
+            for (const id of committedMembers.values()) {
+                const run = this.runs.get(id);
+                if (run.status !== 'accepted' || !['manual', 'confirm'].includes(run.executionStart ?? ''))
+                    throw new ServiceError('CONFLICT', '任务已开始或已取消，请刷新。');
+            }
+            const batch = committedMembers.get(plan.targetId);
+            for (const [nodeId, id] of committedMembers) {
+                const dependencies = plan.edges.filter(e => e.targetId === nodeId).map(e => committedMembers.get(e.sourceId) ?? reused.get(e.sourceId));
+                this.setMode(id, 'dependencies', { chainBatch: batch, chainDependencies: dependencies });
+                this.runs.record(id, 'workflow', { message: '执行范围已确认，等待前驱交付。', targetRunId: batch, predecessorRunIds: dependencies });
+            }
+            return this.runs.get(batch);
+        };
+    }
+    async pump() {
+        if (this.stopped || this.pumping || this.runs.repo.setting('acceptingRuns') !== true)
+            return;
+        this.pumping = true;
+        try {
+            for (const run of this.runs.list().filter(r => r.status === 'accepted' && r.executionStart === 'dependencies')) {
+                if (this.runs.get(run.id).status !== 'accepted')
+                    continue;
+                const runtime = this.runs.runtime(run.id);
+                const dependencies = runtime.details.chainDependencies.map(id => this.runs.get(id));
+                const failed = dependencies.find(r => isTerminalRunStatus(r.status) && r.status !== 'succeeded');
+                if (failed) {
+                    this.runs.transition(run.id, runtime, 'failed', { error: '前驱任务未成功，已停止下游执行。', failedPredecessorRunId: failed.id });
+                    continue;
+                }
+                if (dependencies.some(r => r.status !== 'succeeded'))
+                    continue;
+                try {
+                    const snapshot = structuredClone(this.runs.snapshot(run.id));
+                    for (const predecessor of dependencies) {
+                        const manifestRow = this.db.prepare('SELECT manifest FROM publication_manifests WHERE run_id=?').get(predecessor.id);
+                        let structuredKeys;
+                        if (manifestRow) {
+                            try {
+                                const parsed = JSON.parse(String(manifestRow['manifest']));
+                                const keys = (parsed.outputs ?? []).filter(item => item.role === 'workgraph-node' && typeof item.outputKey === 'string').map(item => String(item.outputKey));
+                                if (keys.length)
+                                    structuredKeys = new Set(keys);
+                            }
+                            catch { /* Persisted publication validation owns corruption handling. */ }
+                        }
+                        const outputRows = this.db.prepare('SELECT o.output_key,o.resource_id,o.resource_version FROM canvas_outputs o WHERE o.run_id=? ORDER BY o.output_key').all(predecessor.id);
+                        const outputs = structuredKeys ? outputRows.filter(output => structuredKeys.has(String(output.output_key))) : outputRows;
+                        if (!outputs.length)
+                            throw new ServiceError('INPUT_BLOCKED', '前驱交付结果不可读取。');
+                        for (const output of outputs) {
+                            const resource = { ...this.resources.readCanvasVersion(run, String(output.resource_id), Number(output.resource_version)), resourceId: String(output.resource_id) };
+                            const bytes = await this.resources.readContent(run, 'canvas', resource.resourceId, resource.version);
+                            if (this.stopped)
+                                return;
+                            const text = resource.mime.startsWith('text/') ? bytes.bytes.toString('utf8') : null;
+                            snapshot.resources.push({ kind: text !== null ? 'document' : resource.mime.startsWith('image/') ? 'image' : 'file', sourceNodeIds: [predecessor.nodeId], text, resource });
+                        }
+                        const files = this.db.prepare('SELECT relative_path FROM project_file_outputs WHERE run_id=? ORDER BY output_key').all(predecessor.id);
+                        snapshot.projectFiles ??= [];
+                        for (const file of files)
+                            snapshot.projectFiles.push({ kind: 'file', relativePath: String(file.relative_path), sourceNodeIds: [predecessor.nodeId], edgeIds: [] });
+                    }
+                    const textBytes = snapshot.resources.reduce((sum, r) => sum + Buffer.byteLength(r.text ?? ''), Buffer.byteLength(snapshot.prompt));
+                    const resourceBytes = snapshot.resources.reduce((sum, r) => sum + (r.resource?.bytes ?? 0), 0);
+                    if (snapshot.resources.length > 64 || textBytes > 33554432 || resourceBytes > 134217728 || snapshot.resources.some(r => Buffer.byteLength(r.text ?? '') > 8388608 || (r.resource?.bytes ?? 0) > 52428800))
+                        throw new ServiceError('INPUT_BUDGET_EXCEEDED', '串联输入超过预算。');
+                    const { inputDigest: _old, ...body } = snapshot;
+                    snapshot.inputDigest = createHash('sha256').update(canonicalJson({ baseInputDigest: _old, predecessorRunIds: dependencies.map(r => r.id), ...body })).digest('hex');
+                    atomic(this.db, () => {
+                        const current = this.runs.get(run.id);
+                        if (current.status !== 'accepted' || this.runs.runtime(run.id).revision !== runtime.revision)
+                            return;
+                        this.graphs.scope(run);
+                        this.graphs.retireExecutionOutputs(run, run.nodeId);
+                        this.db.prepare('INSERT INTO execution_input_snapshots(run_id,payload) VALUES(?,?)').run(run.id, canonicalJson(snapshot));
+                        this.db.prepare('UPDATE runs SET input_digest=? WHERE id=?').run(snapshot.inputDigest, run.id);
+                        for (const envelope of snapshot.resources)
+                            if (envelope.resource) {
+                                const r = envelope.resource;
+                                if (!this.db.prepare("SELECT 1 FROM canvas_resource_references WHERE run_id=? AND resource_id=? AND resource_version=? AND owner_kind='snapshot'").get(run.id, r.resourceId, r.version))
+                                    this.db.prepare("INSERT INTO canvas_resource_references(id,resource_id,resource_version,graph_id,owner_kind,run_id) VALUES(?,?,?,?,'snapshot',?)").run(randomUUID(), r.resourceId, r.version, run.graphId, run.id);
+                            }
+                        this.runs.transition(run.id, runtime, 'queued');
+                    });
+                }
+                catch (error) {
+                    if (this.stopped)
+                        return;
+                    if (this.runs.get(run.id).status === 'accepted')
+                        this.runs.transition(run.id, this.runs.runtime(run.id), 'failed', { error: error instanceof Error ? error.message : String(error) });
+                }
+            }
+        }
+        finally {
+            this.pumping = false;
+        }
+    }
+}
+//# sourceMappingURL=execution-chains.js.map

package/dist/execution-settings.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ExecutionSettings, SandboxMode } from "./vendor/protocol/index.js";
+export declare function sandboxMode(value: unknown): SandboxMode;
+/** Runtime-local settings, persisted with CAS. Codex enforces their permissions. */
+export declare class ExecutionSettingsStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    get(): ExecutionSettings;
+    set(mode: unknown, expectedRevision: unknown): ExecutionSettings;
+}

package/dist/execution-settings.js

@@ -0,0 +1,38 @@
+import { ServiceError } from './errors.js';
+export function sandboxMode(value) {
+    if (value !== 'read-only' && value !== 'workspace-write' && value !== 'danger-full-access')
+        throw new ServiceError('INVALID_REQUEST', '请选择有效的沙盒权限范围。');
+    return value;
+}
+/** Runtime-local settings, persisted with CAS. Codex enforces their permissions. */
+export class ExecutionSettingsStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get() {
+        const row = this.db.prepare("SELECT value FROM settings WHERE key='executionSettings'").get();
+        if (!row)
+            return { revision: 0, sandboxMode: 'workspace-write' };
+        const value = JSON.parse(String(row.value));
+        if (!Number.isSafeInteger(value.revision) || value.revision < 1)
+            throw new ServiceError('MAINTENANCE', '运行时权限设置损坏。');
+        return { revision: value.revision, sandboxMode: sandboxMode(value.sandboxMode) };
+    }
+    set(mode, expectedRevision) {
+        const selected = sandboxMode(mode);
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0 || expectedRevision >= Number.MAX_SAFE_INTEGER)
+            throw new ServiceError('INVALID_REQUEST', '权限设置修订号无效。');
+        const current = this.get();
+        if (current.revision !== expectedRevision)
+            throw new ServiceError('REVISION_CONFLICT', '权限设置已变化，请刷新后重试。');
+        const next = { revision: current.revision + 1, sandboxMode: selected };
+        const result = current.revision === 0
+            ? this.db.prepare("INSERT OR IGNORE INTO settings(key,value) VALUES('executionSettings',?)").run(JSON.stringify(next))
+            : this.db.prepare("UPDATE settings SET value=? WHERE key='executionSettings' AND json_extract(value,'$.revision')=?").run(JSON.stringify(next), current.revision);
+        if (result.changes !== 1)
+            throw new ServiceError('REVISION_CONFLICT', '权限设置已变化，请刷新后重试。');
+        return next;
+    }
+}
+//# sourceMappingURL=execution-settings.js.map

package/dist/graph-document-history.d.ts

@@ -0,0 +1,43 @@
+import type { DatabaseSync, SQLInputValue } from 'node:sqlite';
+import { type GraphDocumentHistory, type GraphHistoryTravel, type GraphScope, type Json } from "./vendor/protocol/index.js";
+import type { Graphs } from './graphs.js';
+type Row = Record<string, SQLInputValue>;
+interface Document {
+    title: string;
+    nodes: Row[];
+    edges: Row[];
+    groups: Row[];
+    members: Row[];
+    outputs: Row[];
+}
+interface Checkpoint {
+    document: Document;
+    execution: number;
+    layout: number;
+    run: number;
+}
+/** One shared document timeline per graph. Only graph command transactions append versions. */
+export declare class GraphDocumentVersions {
+    private graphs;
+    private db;
+    constructor(graphs: Graphs, db?: DatabaseSync);
+    private runSequence;
+    private active;
+    private head;
+    private valid;
+    state(scope: GraphScope): GraphDocumentHistory;
+    capture(scope: GraphScope): Checkpoint;
+    clear(id: string): void;
+    private append;
+    private anchorActiveRuns;
+    /** Upgrade an already-running graph from the pre-gate history format. */
+    backfillActiveGates(): void;
+    /** A submitted Run is a one-way gate anchored after the last editable version. */
+    recordRunSubmission(scope: GraphScope, runId: string, before: Checkpoint): void;
+    /** Run publication may advance graph revisions outside the user command queue. */
+    completeRun(scope: GraphScope, runId: string, published?: boolean): void;
+    record(scope: GraphScope, before: Checkpoint, boundary?: boolean): void;
+    travel(request: GraphHistoryTravel, principal: string): Json;
+    private restore;
+}
+export {};

package/dist/graph-document-history.js

@@ -0,0 +1,275 @@
+import { TERMINAL_RUN_STATUSES } from "./vendor/protocol/index.js";
+import { resourceLinks } from './graphs.js';
+import { canonicalJson } from './persistence/repositories.js';
+import { ServiceError } from './errors.js';
+const TTL = 24 * 60 * 60 * 1000;
+const MAX_VERSIONS = 51;
+const MAX_BYTES = 64 * 1024 * 1024;
+const empty = () => ({ cursor: null, canUndo: false, canRedo: false, expiresAt: null });
+/** One shared document timeline per graph. Only graph command transactions append versions. */
+export class GraphDocumentVersions {
+    graphs;
+    db;
+    constructor(graphs, db = graphs.db) {
+        this.graphs = graphs;
+        this.db = db;
+    }
+    runSequence(id) {
+        return Number(this.db.prepare('SELECT coalesce(max(sequence),0) AS n FROM runs WHERE graph_id=?').get(id)['n']);
+    }
+    active(id) {
+        return !!this.db.prepare('SELECT 1 FROM runs WHERE graph_id=? AND status NOT IN (' + TERMINAL_RUN_STATUSES.map(() => '?').join(',') + ') UNION ALL SELECT 1 FROM occupancy o JOIN runs r ON r.id=o.run_id WHERE r.graph_id=? LIMIT 1').get(id, ...TERMINAL_RUN_STATUSES, id);
+    }
+    head(id) { return this.db.prepare('SELECT * FROM graph_document_heads WHERE graph_id=?').get(id); }
+    valid(scope) {
+        const graph = this.graphs.scope(scope), head = this.head(scope.graphId);
+        return head && Number(head['expires_at']) > Date.now() && !graph['archived'] && !graph['trashed']
+            && head['execution_revision'] === graph['execution_revision'] && head['layout_revision'] === graph['layout_revision']
+            && head['run_sequence'] === this.runSequence(scope.graphId) ? head : undefined;
+    }
+    state(scope) {
+        const head = this.valid(scope);
+        if (!head)
+            return empty();
+        const cursor = Number(head['cursor']);
+        const gates = this.db.prepare('SELECT g.run_id,r.status FROM graph_document_run_gates g JOIN runs r ON r.id=g.run_id WHERE g.graph_id=? AND g.cursor=? ORDER BY r.sequence').all(scope.graphId, cursor);
+        if (this.active(scope.graphId) && !this.db.prepare('SELECT 1 FROM graph_document_run_gates WHERE graph_id=? LIMIT 1').get(scope.graphId))
+            return empty();
+        return { cursor: String(cursor), expiresAt: Number(head['expires_at']), undoRunIds: gates.filter(g => !TERMINAL_RUN_STATUSES.includes(String(g['status']))).map(g => String(g['run_id'])),
+            canUndo: gates.length > 0 || !!this.db.prepare('SELECT 1 FROM graph_document_versions WHERE graph_id=? AND id<? LIMIT 1').get(scope.graphId, cursor),
+            canRedo: !!this.db.prepare('SELECT 1 FROM graph_document_versions WHERE graph_id=? AND id>? LIMIT 1').get(scope.graphId, cursor) };
+    }
+    capture(scope) {
+        const graph = this.graphs.scope(scope), id = scope.graphId;
+        const document = {
+            title: String(graph['title']),
+            nodes: this.db.prepare('SELECT n.id,n.type,n.schema_version,n.x,n.y,n.width,n.height,n.read_only,n.read_only_reason,n.deleted,v.content FROM nodes n JOIN node_versions v ON v.node_id=n.id AND v.version=n.current_version WHERE n.graph_id=? AND (n.deleted=0 OR EXISTS(SELECT 1 FROM execution_outputs o WHERE o.node_id=n.id)) ORDER BY n.creation_order').all(id),
+            edges: this.db.prepare('SELECT id,source_id,target_id,kind FROM edges WHERE graph_id=? ORDER BY id').all(id),
+            groups: this.db.prepare('SELECT id,run_id,title FROM graph_groups WHERE graph_id=? ORDER BY id').all(id),
+            members: this.db.prepare('SELECT m.group_id,m.node_id FROM group_members m JOIN graph_groups g ON g.id=m.group_id WHERE g.graph_id=? ORDER BY m.group_id,m.node_id').all(id),
+            outputs: this.db.prepare('SELECT o.node_id,o.execution_node_id FROM execution_outputs o JOIN nodes n ON n.id=o.node_id WHERE n.graph_id=? ORDER BY o.node_id').all(id),
+        };
+        return { document, execution: Number(graph['execution_revision']), layout: Number(graph['layout_revision']), run: this.runSequence(id) };
+    }
+    clear(id) {
+        this.db.prepare('DELETE FROM graph_document_heads WHERE graph_id=?').run(id);
+        this.db.prepare('DELETE FROM graph_document_versions WHERE graph_id=?').run(id);
+    }
+    append(scope, document) {
+        const id = Number(this.db.prepare('INSERT INTO graph_document_versions(graph_id,document) VALUES(?,?)').run(scope.graphId, canonicalJson(document)).lastInsertRowid);
+        for (const node of document.nodes)
+            for (const link of resourceLinks(JSON.parse(String(node['content'])))) {
+                this.db.prepare('INSERT OR IGNORE INTO graph_document_resources(version_id,resource_id,resource_version) VALUES(?,?,?)').run(id, link.resourceId, link.version);
+            }
+        return id;
+    }
+    anchorActiveRuns(graphId, cursor, excludeRunId) {
+        const statuses = TERMINAL_RUN_STATUSES.map(() => '?').join(',');
+        this.db.prepare('INSERT OR IGNORE INTO graph_document_run_gates(run_id,graph_id,cursor) '
+            + 'SELECT r.id,r.graph_id,? FROM runs r WHERE r.graph_id=? AND r.status NOT IN (' + statuses + ') '
+            + 'AND r.id<>? AND NOT EXISTS(SELECT 1 FROM graph_document_run_gates g WHERE g.run_id=r.id)').run(cursor, graphId, ...TERMINAL_RUN_STATUSES, excludeRunId ?? '');
+    }
+    /** Upgrade an already-running graph from the pre-gate history format. */
+    backfillActiveGates() {
+        const rows = this.db.prepare('SELECT r.id,r.graph_id,r.project_id FROM runs r WHERE r.status NOT IN (' + TERMINAL_RUN_STATUSES.map(() => '?').join(',') + ') AND NOT EXISTS(SELECT 1 FROM graph_document_run_gates g WHERE g.run_id=r.id) ORDER BY r.sequence').all(...TERMINAL_RUN_STATUSES);
+        for (const row of rows) {
+            const scope = { serviceId: this.graphs.serviceId, projectId: String(row['project_id']), graphId: String(row['graph_id']) };
+            this.db.exec('SAVEPOINT history_gate_backfill');
+            try {
+                const head = this.head(scope.graphId);
+                const graph = this.graphs.scope(scope);
+                if (!head || Number(head['expires_at']) <= Date.now() || head['execution_revision'] !== graph['execution_revision'] || head['layout_revision'] !== graph['layout_revision']) {
+                    this.clear(scope.graphId);
+                    const snapshot = this.capture(scope);
+                    const cursor = this.append(scope, snapshot.document);
+                    this.db.prepare('INSERT INTO graph_document_heads VALUES(?,?,?,?,?,?)').run(scope.graphId, cursor, snapshot.execution, snapshot.layout, snapshot.run, Date.now() + TTL);
+                }
+                else {
+                    // Legacy submissions advanced runs.sequence without updating the existing history head.
+                    this.db.prepare('UPDATE graph_document_heads SET run_sequence=? WHERE graph_id=?').run(this.runSequence(scope.graphId), scope.graphId);
+                }
+                this.db.prepare('INSERT OR IGNORE INTO graph_document_run_gates(run_id,graph_id,cursor) VALUES(?,?,?)').run(row['id'], scope.graphId, this.head(scope.graphId)['cursor']);
+                this.db.exec('RELEASE history_gate_backfill');
+            }
+            catch (error) {
+                this.db.exec('ROLLBACK TO history_gate_backfill; RELEASE history_gate_backfill');
+                throw error;
+            }
+        }
+    }
+    /** A submitted Run is a one-way gate anchored after the last editable version. */
+    recordRunSubmission(scope, runId, before) {
+        if (!this.db.isTransaction)
+            throw Error('Run history gate requires the submission transaction');
+        const id = scope.graphId, after = this.capture(scope);
+        let head = this.head(id);
+        if (!head || Number(head['expires_at']) <= Date.now() || head['execution_revision'] !== before.execution || head['layout_revision'] !== before.layout || head['run_sequence'] !== before.run) {
+            this.clear(id);
+            const baseline = this.append(scope, before.document);
+            this.db.prepare('INSERT INTO graph_document_heads VALUES(?,?,?,?,?,?)').run(id, baseline, before.execution, before.layout, before.run, Date.now() + TTL);
+            head = this.head(id);
+        }
+        let cursor = Number(head['cursor']);
+        // A history reset may have cascaded an older active Run's gate. Re-anchor it
+        // before this submission's own document change, which gets a separate gate.
+        this.anchorActiveRuns(id, cursor, runId);
+        this.db.prepare('DELETE FROM graph_document_versions WHERE graph_id=? AND id>?').run(id, cursor);
+        if (canonicalJson(before.document) !== canonicalJson(after.document)) {
+            cursor = this.append(scope, after.document);
+        }
+        this.db.prepare('INSERT INTO graph_document_run_gates(run_id,graph_id,cursor) VALUES(?,?,?)').run(runId, id, cursor);
+        this.db.prepare('UPDATE graph_document_heads SET cursor=?,execution_revision=?,layout_revision=?,run_sequence=? WHERE graph_id=?').run(cursor, after.execution, after.layout, after.run, id);
+    }
+    /** Run publication may advance graph revisions outside the user command queue. */
+    completeRun(scope, runId, published = false) {
+        if (!this.db.isTransaction)
+            throw Error('Run history settlement requires a transaction');
+        const gate = this.db.prepare('SELECT cursor FROM graph_document_run_gates WHERE graph_id=? AND run_id=?').get(scope.graphId, runId);
+        if (!gate)
+            return;
+        const head = this.head(scope.graphId);
+        if (!head)
+            return;
+        const current = this.capture(scope);
+        if (!published)
+            return;
+        const stored = this.db.prepare('SELECT document FROM graph_document_versions WHERE id=? AND graph_id=?').get(head['cursor'], scope.graphId);
+        if (!stored)
+            return;
+        const before = JSON.parse(String(stored['document']));
+        const after = current.document;
+        const collections = [
+            { field: 'nodes', key: row => String(row['id']) }, { field: 'edges', key: row => String(row['id']) },
+            { field: 'groups', key: row => String(row['id']) }, { field: 'members', key: row => JSON.stringify([row['group_id'], row['node_id']]) },
+            { field: 'outputs', key: row => String(row['node_id']) },
+        ];
+        for (const version of this.db.prepare('SELECT id,document FROM graph_document_versions WHERE graph_id=?').all(scope.graphId)) {
+            const document = JSON.parse(String(version['document']));
+            if (before.title !== after.title)
+                document.title = after.title;
+            for (const { field, key } of collections) {
+                const oldRows = new Map(before[field].map(row => [key(row), row]));
+                const nextRows = new Map(after[field].map(row => [key(row), row]));
+                const changed = new Set([...oldRows.keys(), ...nextRows.keys()].filter(id => canonicalJson((oldRows.get(id) ?? null)) !== canonicalJson((nextRows.get(id) ?? null))));
+                document[field] = document[field].filter(row => !changed.has(key(row)) || nextRows.has(key(row))).map(row => {
+                    const id = key(row), old = oldRows.get(id), next = nextRows.get(id);
+                    if (!changed.has(id) || !old || !next)
+                        return row;
+                    const merged = { ...row };
+                    for (const [name, value] of Object.entries(next))
+                        if (canonicalJson((old[name] ?? null)) !== canonicalJson((value ?? null)))
+                            merged[name] = value;
+                    return merged;
+                });
+                for (const [id, row] of nextRows)
+                    if (changed.has(id) && !document[field].some(item => key(item) === id))
+                        document[field].push(row);
+            }
+            this.db.prepare('UPDATE graph_document_versions SET document=? WHERE id=?').run(canonicalJson(document), version['id']);
+            this.db.prepare('DELETE FROM graph_document_resources WHERE version_id=?').run(version['id']);
+            for (const node of document.nodes)
+                for (const link of resourceLinks(JSON.parse(String(node['content']))))
+                    this.db.prepare('INSERT OR IGNORE INTO graph_document_resources(version_id,resource_id,resource_version) VALUES(?,?,?)').run(version['id'], link.resourceId, link.version);
+        }
+        this.db.prepare('UPDATE graph_document_heads SET execution_revision=?,layout_revision=?,run_sequence=? WHERE graph_id=?').run(current.execution, current.layout, current.run, scope.graphId);
+    }
+    record(scope, before, boundary = false) {
+        if (!this.db.isTransaction)
+            throw Error('Document history requires the command transaction');
+        const after = this.capture(scope), id = scope.graphId;
+        if (boundary) {
+            this.clear(id);
+            return;
+        }
+        let head = this.head(id);
+        if (!head || Number(head['expires_at']) <= Date.now() || head['execution_revision'] !== before.execution || head['layout_revision'] !== before.layout || head['run_sequence'] !== before.run) {
+            this.clear(id);
+            const baseline = this.append(scope, before.document);
+            this.db.prepare('INSERT INTO graph_document_heads VALUES(?,?,?,?,?,?)').run(id, baseline, before.execution, before.layout, before.run, Date.now() + TTL);
+            head = this.head(id);
+        }
+        let cursor = Number(head['cursor']);
+        // Keep active Runs gated even when a stale head required a new baseline.
+        // Also repair a missing gate before appending the current user command.
+        this.anchorActiveRuns(id, cursor);
+        if (canonicalJson(before.document) !== canonicalJson(after.document)) {
+            this.db.prepare('DELETE FROM graph_document_versions WHERE graph_id=? AND id>?').run(id, cursor);
+            cursor = this.append(scope, after.document);
+        }
+        this.db.prepare('UPDATE graph_document_heads SET cursor=?,execution_revision=?,layout_revision=?,run_sequence=? WHERE graph_id=?').run(cursor, after.execution, after.layout, after.run, id);
+        const versions = this.db.prepare('SELECT id,length(CAST(document AS BLOB)) AS bytes FROM graph_document_versions WHERE graph_id=? ORDER BY id DESC').all(id);
+        let bytes = 0;
+        for (let i = 0; i < versions.length; i++) {
+            const v = versions[i];
+            bytes += Number(v['bytes']);
+            if ((i >= MAX_VERSIONS || bytes > MAX_BYTES) && Number(v['id']) < cursor)
+                this.db.prepare('DELETE FROM graph_document_versions WHERE id=?').run(v['id']);
+        }
+    }
+    travel(request, principal) {
+        if (!['undo', 'redo'].includes(request.direction) || typeof request.expectedCursor !== 'string' || !request.expectedCursor || !Number.isSafeInteger(request.expectedExecutionRevision) || !Number.isSafeInteger(request.expectedLayoutRevision))
+            throw new ServiceError('INVALID_REQUEST', '撤销重做需要方向、历史游标和整数修订号。');
+        return this.graphs.repo.idempotent(principal + ':graph.history:' + request.graphId, request.idempotencyKey, request, () => {
+            const graph = this.graphs.writable(request);
+            const head = this.valid(request);
+            if (this.active(request.graphId) && !this.db.prepare('SELECT 1 FROM graph_document_run_gates WHERE graph_id=? LIMIT 1').get(request.graphId))
+                throw new ServiceError('ACTIVE_RUN', '图中存在正在运行的任务，请先等待任务结束。');
+            if (!head || String(head['cursor']) !== request.expectedCursor || graph['execution_revision'] !== request.expectedExecutionRevision || graph['layout_revision'] !== request.expectedLayoutRevision)
+                throw new ServiceError('REVISION_CONFLICT', '工作图或历史版本已变化，请读取最新状态后重试。');
+            const gates = request.direction === 'undo' ? this.db.prepare('SELECT g.run_id,r.status FROM graph_document_run_gates g JOIN runs r ON r.id=g.run_id WHERE g.graph_id=? AND g.cursor=?').all(request.graphId, Number(head['cursor'])) : [];
+            if (gates.some(g => !TERMINAL_RUN_STATUSES.includes(String(g['status']))))
+                throw new ServiceError('ACTIVE_RUN', '请先确认停止正在运行的任务，并等待运行时完成收尾。');
+            const target = this.db.prepare('SELECT id,document FROM graph_document_versions WHERE graph_id=? AND id' + (request.direction === 'undo' ? '<' : '>') + '? ORDER BY id ' + (request.direction === 'undo' ? 'DESC' : 'ASC') + ' LIMIT 1').get(request.graphId, Number(head['cursor']));
+            if (!target && !gates.length)
+                throw new ServiceError('CONFLICT', request.direction === 'undo' ? '没有可撤销操作。' : '没有可重做操作。');
+            if (gates.length)
+                this.db.prepare('DELETE FROM graph_document_run_gates WHERE graph_id=? AND cursor=?').run(request.graphId, Number(head['cursor']));
+            if (!target)
+                return this.graphs.snapshot(request);
+            this.restore(request, JSON.parse(String(target['document'])));
+            this.db.prepare('UPDATE graphs SET execution_revision=execution_revision+1,layout_revision=layout_revision+1 WHERE id=?').run(request.graphId);
+            this.db.prepare('UPDATE graph_document_heads SET cursor=?,execution_revision=?,layout_revision=? WHERE graph_id=?').run(target['id'], request.expectedExecutionRevision + 1, request.expectedLayoutRevision + 1, request.graphId);
+            this.graphs.event(request);
+            return this.graphs.snapshot(request);
+        });
+    }
+    restore(scope, doc) {
+        const id = scope.graphId;
+        // Stable node identities preserve selection and Run foreign keys. Body versions never rewind.
+        this.db.prepare('DELETE FROM edges WHERE graph_id=?').run(id);
+        this.db.prepare('DELETE FROM group_members WHERE group_id IN (SELECT id FROM graph_groups WHERE graph_id=?)').run(id);
+        this.db.prepare('DELETE FROM graph_groups WHERE graph_id=?').run(id);
+        this.db.prepare('DELETE FROM execution_outputs WHERE node_id IN (SELECT id FROM nodes WHERE graph_id=?)').run(id);
+        this.db.prepare("DELETE FROM canvas_resource_references WHERE graph_id=? AND owner_kind='node'").run(id);
+        const live = new Set(doc.nodes.map(n => String(n['id'])));
+        for (const n of this.db.prepare('SELECT id FROM nodes WHERE graph_id=? AND deleted=0').all(id))
+            if (!live.has(String(n['id']))) {
+                this.db.prepare('UPDATE nodes SET deleted=1,undo_expires_at=NULL WHERE id=?').run(n['id']);
+                this.db.prepare('DELETE FROM node_resource_history WHERE node_id=?').run(n['id']);
+            }
+        for (const n of doc.nodes) {
+            const current = this.db.prepare('SELECT n.*,v.content FROM nodes n JOIN node_versions v ON v.node_id=n.id AND v.version=n.current_version WHERE n.id=? AND n.graph_id=?').get(n['id'], id);
+            if (!current)
+                throw new ServiceError('CONFLICT', '历史节点已不存在，无法恢复。');
+            let version = Number(current['current_version']);
+            if (current['content'] !== n['content'] || current['type'] !== n['type'] || current['deleted'] !== n['deleted']) {
+                version = Number(this.db.prepare('SELECT max(version)+1 AS n FROM node_versions WHERE node_id=?').get(n['id'])['n']);
+                this.db.prepare('INSERT INTO node_versions(node_id,version,content) VALUES(?,?,?)').run(n['id'], version, n['content']);
+            }
+            this.db.prepare('UPDATE nodes SET type=?,schema_version=?,current_version=?,x=?,y=?,width=?,height=?,read_only=?,read_only_reason=?,deleted=?,undo_expires_at=NULL WHERE id=?').run(n['type'], n['schema_version'], version, n['x'], n['y'], n['width'], n['height'], n['read_only'], n['read_only_reason'], n['deleted'], n['id']);
+            this.graphs.retainResources(scope, String(n['id']), version, JSON.parse(String(n['content'])));
+            if (n['deleted'])
+                this.db.prepare("DELETE FROM canvas_resource_references WHERE owner_kind='node' AND node_id=?").run(n['id']);
+        }
+        for (const g of doc.groups)
+            this.db.prepare('INSERT INTO graph_groups(id,graph_id,run_id,title) VALUES(?,?,?,?)').run(g['id'], id, g['run_id'], g['title']);
+        for (const m of doc.members)
+            this.db.prepare('INSERT INTO group_members(group_id,node_id) VALUES(?,?)').run(m['group_id'], m['node_id']);
+        for (const o of doc.outputs)
+            this.db.prepare('INSERT INTO execution_outputs(node_id,execution_node_id) VALUES(?,?)').run(o['node_id'], o['execution_node_id']);
+        for (const e of doc.edges)
+            this.db.prepare('INSERT INTO edges(id,graph_id,source_id,target_id,kind) VALUES(?,?,?,?,?)').run(e['id'], id, e['source_id'], e['target_id'], e['kind']);
+        this.db.prepare('UPDATE graphs SET title=? WHERE id=?').run(doc.title, id);
+    }
+}
+//# sourceMappingURL=graph-document-history.js.map

package/dist/graph-files.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** Only explicit graph purges enqueue IDs. Never enumerate user projects or
+ * infer orphan ownership. Retain failed entries across restarts for retry. */
+export declare class GraphFiles {
+    readonly db: DatabaseSync;
+    readonly runsDirectory: string;
+    private pending;
+    constructor(db: DatabaseSync, runsDirectory: string);
+    drain(): Promise<{
+        removed: number;
+        failed: number;
+    }>;
+    private work;
+}