@ixo/editor 6.33.0 → 6.34.0

package/dist/chunk-3O42FYT3.js

@@ -0,0 +1,3333 @@
+import {
+  appendAgentLedgerEvent,
+  capabilityForCommand,
+  computeAgentCommandId,
+  createIntentHash,
+  createYDocRuntimeManager,
+  deriveBlockPhase,
+  evaluateBlockExecutionEligibilityForRun,
+  executeActionBlock,
+  getAssigneeDid,
+  getBlockActionType,
+  getBlockId,
+  getBlockProps,
+  getBlockTitle,
+  getBlockType,
+  getDueAt,
+  getFlowAgentMaps,
+  isRuntimeRef,
+  parseConditionConfigStrict,
+  parseJsonProp,
+  queueAgentCommand,
+  readAgentCommands,
+  readPendingInvocations,
+  readQueuedAgentCommands,
+  updateAgentCommand
+} from "./chunk-HRRI4BLF.js";
+import {
+  boundRunActionOutput,
+  generateActionManifest,
+  readPendingRunTimelineEvents,
+  retryPendingRunTimelineEvents
+} from "./chunk-F4PTFXZH.js";
+import {
+  createDesignPodPortalJourneyPlan,
+  seedDesignPodMethodDefinition
+} from "./chunk-JIDTNKKL.js";
+import {
+  capabilityPatternCoversCan,
+  collectPhantomLegacyRun,
+  getAction,
+  getActionByCan,
+  getEventsForBlock,
+  hasLegacyRuntimeHistory,
+  readActionState,
+  resetActionState,
+  resolveActiveRunId,
+  resolveRunIdForExecution,
+  resolveRunIdForRead,
+  setMultiRunStorage,
+  sha256Digest,
+  writeActionState
+} from "./chunk-IIIZZ4E4.js";
+import {
+  isYMapLike,
+  isYXmlElementLike
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/lib/sharedFlowDocument.ts
+import { MatrixCRDTEventTranslator, MatrixProvider, MatrixReader } from "@ixo/matrix-crdt";
+import { Direction, Filter } from "matrix-js-sdk";
+import * as Y from "yjs";
+
+// src/core/lib/flowDocumentCache.ts
+var DATABASE = "ixo-flow-checkpoints-v1";
+var MAX_AGE = 7 * 24 * 60 * 60 * 1e3;
+async function identity(client, roomId) {
+  const token = client.getAccessToken?.();
+  if (!token || !globalThis.crypto?.subtle || typeof indexedDB === "undefined") return;
+  const scope = JSON.stringify([client.getHomeserverUrl(), client.getUserId(), roomId]);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${scope}\0${token}`));
+  const key = await crypto.subtle.importKey("raw", digest, "AES-GCM", false, ["encrypt", "decrypt"]);
+  return { scope, key };
+}
+async function database() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DATABASE, 1);
+    request.onupgradeneeded = () => request.result.createObjectStore("documents");
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => reject(new Error("Flow cache is blocked"));
+  });
+}
+async function readFlowCheckpoint(client, roomId) {
+  try {
+    const auth = await identity(client, roomId);
+    if (!auth) return;
+    const db = await database();
+    const record = await new Promise((resolve, reject) => {
+      const transaction = db.transaction("documents", "readonly");
+      const request = transaction.objectStore("documents").get(auth.scope);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+      transaction.oncomplete = () => db.close();
+      transaction.onabort = () => db.close();
+    });
+    if (!record || Date.now() - record.savedAt > MAX_AGE) return;
+    const clear = await crypto.subtle.decrypt({ name: "AES-GCM", iv: new Uint8Array(record.iv), additionalData: new TextEncoder().encode(auth.scope) }, auth.key, record.data);
+    const value = JSON.parse(new TextDecoder().decode(clear));
+    if (!Array.isArray(value.update) || !value.token) return;
+    return { update: new Uint8Array(value.update), token: value.token, savedAt: record.savedAt };
+  } catch {
+    return;
+  }
+}
+async function writeFlowCheckpoint(client, roomId, checkpoint) {
+  try {
+    if (checkpoint.update.byteLength > 8 * 1024 * 1024) return;
+    const auth = await identity(client, roomId);
+    if (!auth) return;
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const data = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv, additionalData: new TextEncoder().encode(auth.scope) },
+      auth.key,
+      new TextEncoder().encode(JSON.stringify({ update: Array.from(checkpoint.update), token: checkpoint.token }))
+    );
+    const db = await database();
+    await new Promise((resolve, reject) => {
+      const transaction = db.transaction("documents", "readwrite");
+      const store = transaction.objectStore("documents");
+      store.put({ iv, data, savedAt: checkpoint.savedAt }, auth.scope);
+      const request = store.openCursor();
+      const records = [];
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          records.sort((a, b) => b.savedAt - a.savedAt);
+          for (const record of records.slice(32)) store.delete(record.key);
+          return;
+        }
+        if (Date.now() - cursor.value.savedAt > MAX_AGE) cursor.delete();
+        else records.push({ key: cursor.key, savedAt: cursor.value.savedAt });
+        cursor.continue();
+      };
+      transaction.oncomplete = () => {
+        db.close();
+        resolve();
+      };
+      transaction.onerror = () => {
+        db.close();
+        reject(transaction.error);
+      };
+      transaction.onabort = () => {
+        db.close();
+        reject(transaction.error);
+      };
+    });
+  } catch {
+    return;
+  }
+}
+
+// src/core/lib/sharedFlowDocument.ts
+var sessions = /* @__PURE__ */ new WeakMap();
+var RETAIN_MS = 5 * 60 * 1e3;
+var activeLoads = 0;
+var loadQueue = [];
+function withLoadSlot(read, visible) {
+  return new Promise((resolve, reject) => {
+    const start = () => {
+      activeLoads++;
+      void read().then(resolve, reject).finally(() => {
+        activeLoads--;
+        loadQueue.sort((a, b) => Number(b.visible) - Number(a.visible));
+        loadQueue.shift()?.start();
+      });
+    };
+    if (activeLoads < 4) start();
+    else loadQueue.push({ visible, start });
+  });
+}
+function syntheticSnapshot(update) {
+  let binary = "";
+  for (const byte of update) binary += String.fromCharCode(byte);
+  return { type: "matrix-crdt.doc_snapshot", event_id: "$local-checkpoint", sender: "@local:cache", origin_server_ts: 0, content: { update: btoa(binary) } };
+}
+function clientWithHistory(client, history) {
+  let first = true;
+  return new Proxy(client, {
+    get(target, property) {
+      if (property === "createMessagesRequest") {
+        return async (...args) => {
+          if (first && !args[1] && args[3] === Direction.Backward) {
+            first = false;
+            const response = await history();
+            if (response) return response;
+          }
+          return target.createMessagesRequest(args[0], args[1], 200, args[3], args[4]);
+        };
+      }
+      const value = Reflect.get(target, property);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+async function readFlowDocumentHistory(client, roomId, checkpoint) {
+  const room = client.getRoom(roomId);
+  if (checkpoint && Date.now() - checkpoint.savedAt > 30 * 60 * 1e3 && room && !room.currentState.getStateEvents("m.room.encryption", "")) checkpoint = void 0;
+  if (checkpoint) {
+    try {
+      Y.decodeUpdate(checkpoint.update);
+    } catch {
+      checkpoint = void 0;
+    }
+  }
+  const translator = new MatrixCRDTEventTranslator();
+  const filter = new Filter(client.getUserId() ?? void 0);
+  filter.setDefinition({ room: { timeline: { types: [...translator.readEventTypes, "m.room.encrypted"] } } });
+  const readerClient = clientWithHistory(client, async () => {
+    let token = checkpoint?.token;
+    let initial = checkpoint ? [syntheticSnapshot(checkpoint.update)] : [];
+    let recent;
+    if (!token) {
+      const room2 = client.getRoom(roomId);
+      if (!room2 || room2.currentState.getStateEvents("m.room.encryption", "")) return;
+      recent = await client.createMessagesRequest(roomId, "", 200, Direction.Backward, filter);
+      if (!recent.end || recent.end === recent.start || recent.chunk.some((event) => translator.isAnySnapshotEvent(event))) return recent;
+      const snapshots = new Filter(client.getUserId() ?? void 0);
+      snapshots.setDefinition({ room: { timeline: { types: ["matrix-crdt.doc_snapshot", "matrix-crdt.doc_snapshot_v2"] } } });
+      try {
+        const page = await client.createMessagesRequest(roomId, "", 1, Direction.Backward, snapshots);
+        if (!page.chunk.length || !page.end) return recent;
+        token = page.end;
+      } catch {
+        return recent;
+      }
+    }
+    try {
+      for (; ; ) {
+        const page = await client.createMessagesRequest(roomId, token, 200, Direction.Forward, filter);
+        initial.push(...page.chunk);
+        if (!page.end || page.end === token || page.chunk.length === 0) {
+          return { chunk: initial.reverse(), start: page.end || token, end: void 0 };
+        }
+        token = page.end;
+      }
+    } catch {
+      return recent;
+    }
+  });
+  let reader = new MatrixReader(readerClient, roomId, translator);
+  try {
+    let events;
+    try {
+      events = await reader.getInitialDocumentUpdateEvents();
+    } catch {
+      reader.dispose();
+      reader = new MatrixReader(
+        clientWithHistory(client, async () => void 0),
+        roomId,
+        translator
+      );
+      events = await reader.getInitialDocumentUpdateEvents();
+    }
+    if (reader.snapshotDegradations.length) {
+      reader.dispose();
+      reader = new MatrixReader(
+        clientWithHistory(client, async () => void 0),
+        roomId,
+        translator
+      );
+      events = await reader.getInitialDocumentUpdateEvents();
+    }
+    const updates = events.map((event) => translator.getUpdateBytes(event)).filter((update) => !!update);
+    return { update: updates.length ? Y.mergeUpdates(updates) : Y.encodeStateAsUpdate(new Y.Doc()), token: reader.latestToken };
+  } finally {
+    reader.dispose();
+  }
+}
+var SharedFlowDocument = class {
+  constructor(client, roomId) {
+    this.client = client;
+    this.roomId = roomId;
+    this.doc = new Y.Doc();
+    this.lastAccess = Date.now();
+    this.status = "disconnected";
+    this.ready = false;
+    this.provider = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.live = /* @__PURE__ */ new Set();
+    this.attempt = 0;
+    this.generation = 0;
+    this.notify = () => {
+      for (const listener of this.listeners) listener();
+    };
+    this.flush = () => {
+      void this.provider?.waitForFlush().catch(() => void 0);
+    };
+    this.reconnect = async () => {
+      clearTimeout(this.retry);
+      this.attempt = 0;
+      await this.stopProvider();
+      await this.connect();
+    };
+  }
+  watchPageExit(enabled) {
+    if (typeof window === "undefined") return;
+    if (enabled) {
+      window.addEventListener("pagehide", this.flush);
+      window.addEventListener("beforeunload", this.flush);
+    } else {
+      window.removeEventListener("pagehide", this.flush);
+      window.removeEventListener("beforeunload", this.flush);
+    }
+  }
+  evictIfIdle() {
+    if (this.listeners.size || this.pending) return false;
+    this.generation++;
+    clearTimeout(this.idle);
+    clearTimeout(this.retry);
+    clearTimeout(this.stopTimer);
+    if (sessions.get(this.client)?.get(this.roomId) === this) sessions.get(this.client)?.delete(this.roomId);
+    void this.stopProvider().finally(() => this.doc.destroy());
+    return true;
+  }
+  subscribe(listener, live = true) {
+    this.lastAccess = Date.now();
+    clearTimeout(this.idle);
+    clearTimeout(this.stopTimer);
+    this.listeners.add(listener);
+    if (live) this.live.add(listener);
+    void this.connect();
+    return () => {
+      this.listeners.delete(listener);
+      this.live.delete(listener);
+      if (!this.live.size && this.provider)
+        this.stopTimer = setTimeout(() => {
+          if (!this.live.size) void this.stopProvider();
+        }, 1e3);
+      if (!this.listeners.size) {
+        clearTimeout(this.retry);
+        this.idle = setTimeout(() => {
+          this.evictIfIdle();
+        }, RETAIN_MS);
+        this.idle.unref?.();
+      }
+    };
+  }
+  connect() {
+    if (this.pending) return this.pending;
+    if (this.provider || this.ready && !this.live.size && this.checkpoint && Date.now() - this.checkpoint.savedAt < 3e4) return Promise.resolve();
+    const generation = this.generation;
+    this.status = "connecting";
+    this.notify();
+    this.pending = (async () => {
+      await this.stopping;
+      if (!this.checkpoint) {
+        const membership = this.client.getRoom(this.roomId)?.getMyMembership?.();
+        if (!membership || membership === "join") this.checkpoint = await readFlowCheckpoint(this.client, this.roomId);
+        if (generation !== this.generation) return;
+        if (this.checkpoint) {
+          try {
+            Y.decodeUpdate(this.checkpoint.update);
+            Y.applyUpdate(this.doc, this.checkpoint.update, this);
+            this.ready = true;
+            this.notify();
+          } catch {
+            this.checkpoint = void 0;
+          }
+        }
+      }
+      const result = await withLoadSlot(() => readFlowDocumentHistory(this.client, this.roomId, this.checkpoint), this.live.size > 0);
+      if (generation !== this.generation) return;
+      Y.applyUpdate(this.doc, result.update, this);
+      this.ready = true;
+      this.error = void 0;
+      this.attempt = 0;
+      if (result.token) this.checkpoint = { update: result.update, token: result.token, savedAt: Date.now() };
+      this.status = this.live.size ? "connecting" : "connected";
+      if (this.live.size) {
+        const providerClient = clientWithHistory(
+          this.client,
+          async () => ({
+            chunk: [syntheticSnapshot(result.update)],
+            start: result.token,
+            end: void 0
+          })
+        );
+        const provider = new MatrixProvider(
+          this.doc,
+          providerClient,
+          { type: "id", id: this.roomId },
+          {
+            translator: { enableMediaSnapshots: true },
+            reader: { snapshotInterval: 10 },
+            writer: { flushInterval: 300, retryIfForbiddenInterval: 3e4 },
+            enableAwareness: true,
+            enableExperimentalWebrtcSync: true
+          }
+        );
+        this.provider = provider;
+        this.watchPageExit(true);
+        provider.onDocumentUnavailable(() => {
+          if (this.provider !== provider) return;
+          this.status = "error";
+          this.error = "Flow document is unavailable";
+          this.notify();
+        });
+        provider.onDocumentAvailable(() => {
+          if (this.provider !== provider) return;
+          this.status = "connected";
+          this.error = void 0;
+          this.notify();
+        });
+        void provider.initialize().catch((error) => {
+          if (this.provider !== provider) return;
+          provider.dispose();
+          this.watchPageExit(false);
+          this.provider = null;
+          this.fail(error);
+        });
+      }
+      this.save();
+      this.notify();
+    })().catch((error) => {
+      if (generation === this.generation) this.fail(error);
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  fail(error) {
+    const code = error?.errcode;
+    if (code === "M_FORBIDDEN" || code === "M_UNKNOWN_TOKEN") {
+      this.ready = false;
+      this.checkpoint = void 0;
+    }
+    this.status = "error";
+    this.error = error instanceof Error ? error.message : String(error);
+    this.notify();
+    clearTimeout(this.retry);
+    if (this.listeners.size) this.retry = setTimeout(() => void this.connect(), Math.min(5e3 * 2 ** this.attempt++, 3e4));
+  }
+  save() {
+    if (this.checkpoint && this.ready) void writeFlowCheckpoint(this.client, this.roomId, this.checkpoint);
+  }
+  async stopProvider() {
+    const provider = this.provider;
+    if (!provider) return;
+    this.save();
+    this.watchPageExit(false);
+    this.provider = null;
+    this.stopping = (async () => {
+      let timer;
+      try {
+        await Promise.race([
+          provider.waitForFlush(),
+          new Promise((resolve) => {
+            timer = setTimeout(resolve, 3e3);
+          })
+        ]);
+      } catch {
+        return;
+      } finally {
+        clearTimeout(timer);
+        provider.dispose();
+      }
+    })();
+    await this.stopping;
+    this.stopping = void 0;
+  }
+};
+function getSharedFlowDocument(client, roomId) {
+  let rooms = sessions.get(client);
+  if (!rooms) {
+    rooms = /* @__PURE__ */ new Map();
+    sessions.set(client, rooms);
+  }
+  let session = rooms.get(roomId);
+  if (!session) {
+    session = new SharedFlowDocument(client, roomId);
+    rooms.set(roomId, session);
+  }
+  session.lastAccess = Date.now();
+  if (rooms.size > 32) {
+    for (const candidate of [...rooms.values()].sort((a, b) => a.lastAccess - b.lastAccess)) {
+      if (rooms.size <= 32) break;
+      if (candidate !== session && Date.now() - candidate.lastAccess > 1e3) candidate.evictIfIdle();
+    }
+  }
+  return session;
+}
+
+// src/core/lib/flowCompiler/conditions.ts
+var OPERATOR_MAP = {
+  // BaseUcan ConditionRef vocabulary
+  eq: "equals",
+  neq: "not_equals",
+  gt: "greater_than",
+  lt: "less_than",
+  in: "contains",
+  exists: "is_not_empty",
+  // Friendly camelCase (plugin FlowSpec `is`)
+  equals: "equals",
+  notEquals: "not_equals",
+  greaterThan: "greater_than",
+  lessThan: "less_than",
+  isEmpty: "is_empty",
+  isNotEmpty: "is_not_empty",
+  // Evaluator vocabulary passthrough
+  not_equals: "not_equals",
+  greater_than: "greater_than",
+  less_than: "less_than",
+  contains: "contains",
+  not_contains: "not_contains",
+  notContains: "not_contains",
+  is_empty: "is_empty",
+  is_not_empty: "is_not_empty"
+};
+function toEvaluatorOperator(operator) {
+  return OPERATOR_MAP[operator] ?? "equals";
+}
+function buildBlockConditionsProp(conditions, opts) {
+  return JSON.stringify({
+    enabled: opts?.enabled ?? true,
+    mode: opts?.mode ?? "all_must_pass",
+    conditions: conditions.map((c, i) => ({
+      id: `cond_${c.sourceBlockId}_${c.property}_${i}`,
+      name: c.name ?? `Condition from ${c.sourceBlockId}`,
+      sourceBlockId: c.sourceBlockId,
+      sourceBlockType: c.sourceBlockType ?? "action",
+      rule: {
+        type: "property_value",
+        property: c.property,
+        operator: toEvaluatorOperator(c.operator),
+        value: c.value
+      },
+      effect: c.effect ?? { action: "enable" }
+    }))
+  });
+}
+
+// src/core/lib/flowCompiler/blockMapping.ts
+var ICON_DEFAULTS = {
+  "bid/submit": "gavel",
+  "bid/evaluate": "check-circle",
+  "claim/submit": "file-check",
+  "claim/evaluate": "clipboard-check",
+  "email/send": "mail",
+  "notification/push": "bell",
+  "matrix/dm": "message-circle",
+  "proposal/create": "scroll",
+  "proposal/vote": "vote",
+  "domain/card-preview": "id",
+  "domain/sign": "feather",
+  "credential/store": "shield",
+  "http/request": "cloud",
+  "protocol/select": "git-branch",
+  "human/checkbox": "check-square",
+  "human/form": "file-text",
+  "form/submit": "file-text",
+  "oracle/query": "cpu"
+};
+function compileBlockProps(cap, registryType) {
+  return {
+    title: cap.title || cap.can,
+    description: cap.description || "",
+    icon: cap.icon || ICON_DEFAULTS[cap.can] || "bolt",
+    actionType: registryType,
+    inputs: JSON.stringify(cap.nb || {}),
+    requiresConfirmation: "",
+    conditions: "",
+    // compiled separately by the compiler
+    // Authorization props
+    parentCapability: cap.actor?.parentCapability || "",
+    authorisedActors: cap.actor?.authorisedActors ? JSON.stringify(cap.actor.authorisedActors) : "",
+    // TTL props
+    ttlAbsoluteDueDate: cap.ttl?.absoluteDueDate || "",
+    ttlFromEnablement: cap.ttl?.fromEnablement || "",
+    ttlFromCommitment: cap.ttl?.fromCommitment || "",
+    // Trigger props (slice D — events and triggers feature). Stored as a
+    // JSON string mirroring how `inputs` serializes `nb`. Default empty
+    // string means "manual" — the runtime treats absent or empty as manual.
+    trigger: cap.trigger ? JSON.stringify(cap.trigger) : ""
+  };
+}
+var COMPILED_BLOCK_TYPE = "action";
+
+// src/core/lib/flowCompiler/compiler.ts
+function stripActiveScheduleBindings(plan) {
+  let changed = false;
+  const capabilities = plan.capabilities.map((cap) => {
+    if (cap.trigger?.type !== "schedule") return cap;
+    if (cap.trigger.scheduleRef === void 0 && cap.trigger.scheduleRevision === void 0) return cap;
+    changed = true;
+    const { scheduleRef: _ref, scheduleRevision: _rev, ...inactive } = cap.trigger;
+    return { ...cap, trigger: inactive };
+  });
+  return changed ? { ...plan, capabilities } : plan;
+}
+function compileBaseUcanFlow(plan, registry) {
+  if (!Array.isArray(plan.capabilities)) {
+    throw new Error("BaseUcanFlow.capabilities must be an array");
+  }
+  const capabilities = plan.capabilities;
+  if (capabilities.length === 0) {
+    throw new Error("BaseUcanFlow has no capabilities to compile");
+  }
+  const actionMap = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    const nodeId = cap.id?.trim();
+    if (!nodeId) {
+      throw new Error("Every capability in BaseUcanFlow.capabilities must include a non-empty id.");
+    }
+    if (actionMap.has(nodeId)) {
+      throw new Error(`Duplicate capability id "${nodeId}" in BaseUcanFlow.capabilities.`);
+    }
+    const action = registry.getActionByCan(cap.can);
+    if (!action) {
+      throw new Error(`Unknown capability "${cap.can}" for node "${nodeId}". Not found in action registry.`);
+    }
+    actionMap.set(nodeId, { action, nodeId, cap });
+  }
+  const blockIndex = {};
+  for (const nodeId of actionMap.keys()) {
+    blockIndex[nodeId] = generateBlockId(nodeId);
+  }
+  const triggerEdges = [];
+  for (const [nodeId, { cap, action }] of actionMap) {
+    const trigger = cap.trigger;
+    if (!trigger) continue;
+    if (trigger.type === "block.event") {
+      if (action.eligibleForEventTrigger !== true) {
+        throw new Error(
+          `Block "${nodeId}" is configured with a block.event trigger, but its action type "${action.type}" is not marked eligibleForEventTrigger. Set eligibleForEventTrigger: true on the action definition or change the trigger to manual.`
+        );
+      }
+      const sourceId = trigger.sourceBlockId?.trim();
+      const eventName = trigger.eventName?.trim();
+      if (!sourceId || !eventName) {
+        throw new Error(`Block "${nodeId}" has a block.event trigger but is missing sourceBlockId or eventName.`);
+      }
+      const source = actionMap.get(sourceId);
+      if (!source) {
+        throw new Error(`Trigger on block "${nodeId}" references unknown source block "${sourceId}".`);
+      }
+      const declaredEvents = getEventsForBlock(source.action, source.cap.nb);
+      if (declaredEvents.length === 0) {
+        throw new Error(`Trigger on block "${nodeId}" references event "${eventName}" but source action "${source.action.type}" declares no events.`);
+      }
+      const found = declaredEvents.find((e) => e.name === eventName);
+      if (!found) {
+        const declared = declaredEvents.map((e) => e.name).join(", ");
+        throw new Error(`Trigger on block "${nodeId}" references unknown event "${eventName}" on action type "${source.action.type}". Declared events: [${declared}]`);
+      }
+      triggerEdges.push({
+        id: `${sourceId}~event:${eventName}~>${nodeId}`,
+        source: sourceId,
+        target: nodeId,
+        kind: "trigger"
+      });
+    }
+    if (trigger.type === "block.event.all") {
+      if (action.eligibleForEventTrigger !== true) {
+        throw new Error(`Block "${nodeId}" is configured with a block.event.all trigger, but its action type "${action.type}" is not marked eligibleForEventTrigger.`);
+      }
+      const sources = trigger.sources || [];
+      if (sources.length === 0) {
+        throw new Error(`Block "${nodeId}" has a block.event.all trigger but no sources configured.`);
+      }
+      for (const src of sources) {
+        const srcId = src.sourceBlockId?.trim();
+        const evtName = src.eventName?.trim();
+        if (!srcId || !evtName) {
+          throw new Error(`Block "${nodeId}" has a block.event.all source with missing sourceBlockId or eventName.`);
+        }
+        const sourceEntry = actionMap.get(srcId);
+        if (!sourceEntry) {
+          throw new Error(`Barrier trigger on block "${nodeId}" references unknown source block "${srcId}".`);
+        }
+        const declaredEvents = getEventsForBlock(sourceEntry.action, sourceEntry.cap.nb);
+        const found = declaredEvents.find((e) => e.name === evtName);
+        if (!found) {
+          const declared = declaredEvents.map((e) => e.name).join(", ");
+          throw new Error(`Barrier trigger on block "${nodeId}" references unknown event "${evtName}" on action type "${sourceEntry.action.type}". Declared events: [${declared}]`);
+        }
+        if (!src.alias?.trim()) {
+          throw new Error(`Barrier trigger on block "${nodeId}" has a source (${srcId}/${evtName}) with no alias.`);
+        }
+        triggerEdges.push({
+          id: `${srcId}~event:${evtName}~>${nodeId}`,
+          source: srcId,
+          target: nodeId,
+          kind: "trigger"
+        });
+      }
+    }
+    if (trigger.type === "schedule") {
+      if (action.eligibleForTimeTrigger !== true) {
+        throw new Error(
+          `Block "${nodeId}" is configured with a schedule trigger, but its action type "${action.type}" is not marked eligibleForTimeTrigger. Set eligibleForTimeTrigger: true on the action definition or change the trigger.`
+        );
+      }
+      if (trigger.sourceBlockId || trigger.sources || trigger.eventName) {
+        throw new Error(
+          `Block "${nodeId}" has a schedule trigger carrying event-trigger fields (sourceBlockId/eventName/sources). A schedule trigger holds only scheduleRef and scheduleRevision \u2014 timing lives in the referenced ScheduleSpec, never in the block.`
+        );
+      }
+      if (trigger.scheduleRevision !== void 0 && (!Number.isInteger(trigger.scheduleRevision) || trigger.scheduleRevision < 1)) {
+        throw new Error(`Block "${nodeId}" has a schedule trigger with an invalid scheduleRevision (must be an integer >= 1).`);
+      }
+    }
+    if (trigger.type === "block.event" || trigger.type === "block.event.all") {
+      const refs = collectOutputRefs(cap.nb || {});
+      for (const ref of refs) {
+        const parsed = parseOutputRef(ref);
+        if (!parsed) continue;
+        if (!actionMap.has(parsed.nodeId)) {
+          throw new Error(`Listener "${nodeId}" references output of unknown block "${parsed.nodeId}" via ref "${ref}".`);
+        }
+      }
+    }
+  }
+  const edges = [...triggerEdges];
+  detectTriggerCycles(triggerEdges);
+  const order = Array.from(actionMap.keys());
+  const blocks = [];
+  const nodes = {};
+  for (const nodeId of order) {
+    const { action, cap } = actionMap.get(nodeId);
+    const blockId = blockIndex[nodeId];
+    const props = compileBlockProps(cap, action.type);
+    if (cap.condition) {
+      props.conditions = compileCondition(cap.condition, blockIndex);
+    }
+    if (cap.trigger) {
+      props.trigger = compileTrigger(cap.trigger, blockIndex);
+    }
+    props.triggerMode = cap.trigger?.type || "manual";
+    blocks.push({
+      id: blockId,
+      type: COMPILED_BLOCK_TYPE,
+      props
+    });
+    nodes[nodeId] = {
+      id: nodeId,
+      blockId,
+      can: cap.can,
+      with: cap.with,
+      registryType: action.type,
+      title: cap.title || cap.can,
+      description: cap.description || "",
+      props,
+      phase: cap.phase,
+      parallelGroup: cap.parallelGroup,
+      actor: cap.actor
+    };
+  }
+  return {
+    meta: {
+      flowId: plan.flowId,
+      title: plan.title,
+      goal: plan.goal,
+      version: plan.version,
+      flowOwnerDid: plan.meta?.rootIssuer || "",
+      flowUri: plan.meta?.flowUri,
+      compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      compiledFrom: "BaseUcanFlow"
+    },
+    blocks,
+    nodes,
+    edges,
+    order,
+    blockIndex
+  };
+}
+function generateBlockId(nodeId) {
+  return `flow_block_${nodeId}`;
+}
+function compileCondition(condition, blockIndex) {
+  const sourceBlockId = blockIndex[condition.sourceId];
+  if (!sourceBlockId) {
+    throw new Error(`Condition references unknown source "${condition.sourceId}".`);
+  }
+  const conditionConfig = {
+    enabled: true,
+    mode: "all_must_pass",
+    conditions: [
+      {
+        id: `cond_${condition.sourceId}_${condition.field}`,
+        name: `Condition from ${condition.sourceId}`,
+        sourceBlockId,
+        sourceBlockType: COMPILED_BLOCK_TYPE,
+        rule: {
+          type: "property_value",
+          property: condition.field,
+          // Map the BaseUcan ConditionRef operator (eq/neq/…) onto the FE evaluator's
+          // vocabulary (equals/not_equals/…). Writing it verbatim is the historical bug
+          // that made compiler-authored conditions silently never evaluate.
+          operator: toEvaluatorOperator(condition.operator),
+          value: condition.value
+        },
+        effect: condition.effect || { action: "enable" }
+      }
+    ]
+  };
+  return JSON.stringify(conditionConfig);
+}
+function compileTrigger(trigger, blockIndex) {
+  if (trigger.type === "block.event" && trigger.sourceBlockId) {
+    return JSON.stringify({ ...trigger, sourceBlockId: blockIndex[trigger.sourceBlockId.trim()] });
+  }
+  if (trigger.type === "block.event.all" && trigger.sources) {
+    return JSON.stringify({
+      ...trigger,
+      sources: trigger.sources.map((src) => ({ ...src, sourceBlockId: blockIndex[src.sourceBlockId.trim()] }))
+    });
+  }
+  return JSON.stringify(trigger);
+}
+function collectOutputRefs(value) {
+  const refs = [];
+  walk(value);
+  return refs;
+  function walk(v) {
+    if (isRuntimeRef(v)) {
+      const r = v.$ref;
+      if (!r.startsWith("trigger.")) refs.push(r);
+      return;
+    }
+    if (Array.isArray(v)) {
+      for (const item of v) walk(item);
+      return;
+    }
+    if (v !== null && typeof v === "object") {
+      for (const inner of Object.values(v)) walk(inner);
+    }
+  }
+}
+function parseOutputRef(ref) {
+  const outputIndex = ref.indexOf(".output.");
+  if (outputIndex === -1) return null;
+  return {
+    nodeId: ref.slice(0, outputIndex),
+    fieldPath: ref.slice(outputIndex + ".output.".length)
+  };
+}
+function detectTriggerCycles(triggerEdges) {
+  if (triggerEdges.length === 0) return;
+  const adjacency = /* @__PURE__ */ new Map();
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const edge of triggerEdges) {
+    if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
+    adjacency.get(edge.source).push(edge.target);
+    allNodes.add(edge.source);
+    allNodes.add(edge.target);
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const id of allNodes) color.set(id, WHITE);
+  const path = [];
+  const visit = (node) => {
+    color.set(node, GRAY);
+    path.push(node);
+    for (const next of adjacency.get(node) || []) {
+      if (color.get(next) === GRAY) {
+        const start = path.indexOf(next);
+        const cycle = path.slice(start).concat(next).join(" \u2192 ");
+        throw new Error(`Trigger cycle detected: ${cycle}. Block.event triggers must form a DAG; remove one of the trigger declarations to break the cycle.`);
+      }
+      if (color.get(next) === WHITE) {
+        visit(next);
+      }
+    }
+    path.pop();
+    color.set(node, BLACK);
+  };
+  for (const id of allNodes) {
+    if (color.get(id) === WHITE) visit(id);
+  }
+}
+
+// src/core/lib/flowCompiler/hydrate.ts
+import * as Y2 from "yjs";
+var DRAFT_CONTROL_MAP = "qi.flow.draftControl";
+var LEGACY_COMMAND_REVISION_KEY = "legacyCommandRevision";
+function nextDraftRevision(yDoc, current) {
+  const currentRevision = Number(current ?? 0);
+  const legacyRevision = Number(yDoc.getMap(DRAFT_CONTROL_MAP).get(LEGACY_COMMAND_REVISION_KEY) ?? 0);
+  return Math.max(0, Number.isFinite(currentRevision) ? currentRevision : 0, Number.isFinite(legacyRevision) ? legacyRevision : 0) + 1;
+}
+function jsonOutputSchema(fields) {
+  if (fields.length === 0) return { type: "object", additionalProperties: true };
+  const properties = {};
+  for (const field of fields) {
+    const [root] = field.path.split(".");
+    if (!root) continue;
+    properties[root] = field.path.includes(".") ? { type: "object" } : { type: field.type };
+  }
+  return { type: "object", properties, additionalProperties: true };
+}
+var ACTION_SAFETY_BY_TYPE = {
+  "qi/noop": "pure",
+  "qi/data.constant": "pure",
+  // Reads a public endpoint and returns the body. No effect to fence.
+  "qi/http.fetch": "pure",
+  // Calls out and may change the far side, so it is not pure — but the runner
+  // makes the call itself, so it is a provider action, not a fenced one. That
+  // keeps the `flow/block/execute` grant every flow already holds sufficient.
+  "qi/http.request": "provider_idempotent"
+};
+function resolveActionSafety(type, executionOwner) {
+  if (executionOwner === "human") return "approval_only";
+  return ACTION_SAFETY_BY_TYPE[type] ?? "fenced";
+}
+function executionContract(node) {
+  const action = getAction(node.registryType);
+  const manifest = generateActionManifest();
+  const entry = manifest.actions.find((candidate) => candidate.type === node.registryType);
+  if (!action || !entry || !entry.can) return void 0;
+  const safety = resolveActionSafety(action.type, action.executionOwner);
+  const contract = {
+    kind: "qi.action.contract",
+    schemaVersion: "1.0",
+    type: action.type,
+    can: entry.can,
+    contractVersion: action.contractVersion,
+    manifestDigest: manifest.manifestDigest,
+    inputSchema: action.inputSchema ?? { type: "object", additionalProperties: true },
+    outputSchema: jsonOutputSchema(entry.outputSchema),
+    safety,
+    handlerVersion: `${action.type}@${action.contractVersion}`,
+    dataClassification: action.sensitiveInputPaths?.length || action.sensitiveOutputPaths?.length ? "confidential" : "shared",
+    requiredServices: [...action.requiredServices ?? []],
+    idempotency: {
+      providerKey: false,
+      readback: safety === "fenced" ? "required" : "unavailable",
+      compensation: "unavailable"
+    },
+    contractDigest: entry.contractDigest
+  };
+  return contract;
+}
+function writeExecutionMeta(yDoc) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  meta.set(
+    "definitionDigest",
+    sha256Digest({
+      nodes: yDoc.getMap("qi.flow.nodes").toJSON(),
+      edges: yDoc.getMap("qi.flow.edges").toJSON(),
+      order: yDoc.getArray("qi.flow.order").toArray()
+    })
+  );
+  meta.set("executionSchemaVersion", 3);
+}
+function rebaseStepResource(authored, flowPrefix, stepIds) {
+  if (authored === flowPrefix || authored.startsWith(`${flowPrefix}:`)) return void 0;
+  for (const stepId of stepIds) {
+    if (stepId && authored.endsWith(`:${stepId}`)) return `${flowPrefix}:${stepId}`;
+  }
+  return void 0;
+}
+function ensureFlowExecutionMetadata(yDoc) {
+  if (yDoc.getMap("qi.flow.meta").get("draftSchemaVersion") !== 1) return false;
+  let changed = false;
+  yDoc.transact(() => {
+    const docId = yDoc.getMap("root").get("doc_id");
+    const flowPrefix = typeof docId === "string" && docId ? `ixo:flow:${docId}` : void 0;
+    for (const [nodeId, value] of yDoc.getMap("qi.flow.nodes").entries()) {
+      if (!(value instanceof Y2.Map)) continue;
+      const registryType = value.get("registryType");
+      if (typeof registryType !== "string" || !registryType) continue;
+      const authoredResource = value.get("with");
+      const rebased = flowPrefix && typeof authoredResource === "string" ? rebaseStepResource(authoredResource, flowPrefix, [String(value.get("id") ?? nodeId), String(value.get("blockId") ?? "")]) : void 0;
+      if (rebased) {
+        value.set("with", rebased);
+        const props = asRecord(value.get("props"));
+        if (props && props.with === authoredResource) value.set("props", { ...props, with: rebased });
+        changed = true;
+      }
+      const executionOwner = getAction(registryType)?.executionOwner ?? "agent";
+      if (value.get("executionOwner") !== executionOwner) {
+        value.set("executionOwner", executionOwner);
+        changed = true;
+      }
+      const contract = executionContract({
+        id: String(value.get("id") ?? nodeId),
+        blockId: String(value.get("blockId") ?? ""),
+        can: String(value.get("can") ?? ""),
+        with: String(value.get("with") ?? ""),
+        registryType,
+        title: String(value.get("title") ?? ""),
+        description: String(value.get("description") ?? ""),
+        props: value.get("props") ?? {}
+      });
+      if (contract && JSON.stringify(value.get("actionContract")) !== JSON.stringify(contract)) {
+        value.set("actionContract", contract);
+        changed = true;
+      }
+    }
+    const meta = yDoc.getMap("qi.flow.meta");
+    if (changed || typeof meta.get("definitionDigest") !== "string" || meta.get("executionSchemaVersion") !== 3) {
+      meta.set("draftRevision", nextDraftRevision(yDoc, meta.get("draftRevision")));
+      writeExecutionMeta(yDoc);
+      meta.set("draftUpdatedAt", (/* @__PURE__ */ new Date()).toISOString());
+      changed = true;
+    }
+  });
+  return changed;
+}
+function adoptLegacyFlowDocument(yDoc) {
+  const adopted = adoptDraftShape(yDoc);
+  const stamped = ensureFlowExecutionMetadata(yDoc);
+  return adopted || stamped;
+}
+function legacyPropsByBlockId(yDoc) {
+  const byBlockId = /* @__PURE__ */ new Map();
+  collectLegacyBlockProps(yDoc.getXmlFragment("document"), byBlockId);
+  return byBlockId;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function collectLegacyBlockProps(parent, out) {
+  for (let index = 0; index < parent.length; index += 1) {
+    const child = parent.get(index);
+    if (!(child instanceof Y2.XmlElement)) continue;
+    if (child.nodeName === "blockContainer") readContainerProps(child, out);
+    collectLegacyBlockProps(child, out);
+  }
+}
+function readContainerProps(container, out) {
+  const attrs = asRecord(container.getAttribute("attrs"));
+  const directId = container.getAttribute("id");
+  const blockId = typeof directId === "string" && directId ? directId : typeof attrs?.id === "string" ? attrs.id : "";
+  if (!blockId) return;
+  const props = {};
+  const addAll = (source) => {
+    for (const [key, value] of Object.entries(source ?? {})) {
+      if (typeof value === "string" && value !== "") props[key] = value;
+    }
+  };
+  addAll(asRecord(attrs?.props));
+  const content = container.get(0);
+  if (content instanceof Y2.XmlElement && content.nodeName !== "blockGroup") addAll(content.getAttributes());
+  const textColor = container.getAttribute("textColor");
+  if (typeof textColor === "string" && textColor !== "default") props.textColor = textColor;
+  const backgroundColor = container.getAttribute("backgroundColor");
+  if (typeof backgroundColor === "string" && backgroundColor !== "default") props.backgroundColor = backgroundColor;
+  if (Object.keys(props).length > 0) out.set(blockId, props);
+}
+function adoptDraftShape(yDoc) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  if (meta.get("draftSchemaVersion") === 1) return false;
+  const nodes = yDoc.getMap("qi.flow.nodes");
+  if (nodes.size === 0) return false;
+  const propsByBlockId = legacyPropsByBlockId(yDoc);
+  yDoc.transact(() => {
+    for (const value of nodes.values()) {
+      if (!(value instanceof Y2.Map)) continue;
+      const existing = value.get("props");
+      if (existing && typeof existing === "object" && Object.keys(existing).length > 0) continue;
+      const blockId = value.get("blockId");
+      const props = typeof blockId === "string" ? propsByBlockId.get(blockId) : void 0;
+      if (props && Object.keys(props).length > 0) value.set("props", { ...props });
+    }
+    meta.set("draftSchemaVersion", 1);
+  });
+  return true;
+}
+function hydrateYDocFromCompiledFlow(yDoc, compiled) {
+  yDoc.transact(() => {
+    const flowMeta = yDoc.getMap("qi.flow.meta");
+    for (const [key, value] of Object.entries(compiled.meta)) {
+      if (value !== void 0) {
+        flowMeta.set(key, value);
+      }
+    }
+    const draftRevision = nextDraftRevision(yDoc, flowMeta.get("draftRevision"));
+    flowMeta.set("draftSchemaVersion", 1);
+    flowMeta.set("draftRevision", draftRevision);
+    const flowNodes = yDoc.getMap("qi.flow.nodes");
+    for (const [nodeId, node] of Object.entries(compiled.nodes)) {
+      flowNodes.set(nodeId, createYMapFromNode(node));
+    }
+    const flowEdges = yDoc.getMap("qi.flow.edges");
+    for (const edge of compiled.edges) {
+      const yEdge = new Y2.Map();
+      yEdge.set("id", edge.id);
+      yEdge.set("source", edge.source);
+      yEdge.set("target", edge.target);
+      yEdge.set("kind", edge.kind);
+      if (edge.condition) yEdge.set("condition", edge.condition);
+      flowEdges.set(edge.id, yEdge);
+    }
+    const flowOrder = yDoc.getArray("qi.flow.order");
+    for (const nodeId of compiled.order) {
+      flowOrder.push([nodeId]);
+    }
+    const flowBlockIndex = yDoc.getMap("qi.flow.blockIndex");
+    for (const [nodeId, blockId] of Object.entries(compiled.blockIndex)) {
+      flowBlockIndex.set(nodeId, blockId);
+    }
+    writeExecutionMeta(yDoc);
+  });
+}
+function clearFlowState(yDoc) {
+  yDoc.transact(() => {
+    const flowMeta = yDoc.getMap("qi.flow.meta");
+    flowMeta.forEach((_, key) => flowMeta.delete(key));
+    const flowNodes = yDoc.getMap("qi.flow.nodes");
+    flowNodes.forEach((_, key) => flowNodes.delete(key));
+    const flowEdges = yDoc.getMap("qi.flow.edges");
+    flowEdges.forEach((_, key) => flowEdges.delete(key));
+    const flowOrder = yDoc.getArray("qi.flow.order");
+    if (flowOrder.length > 0) {
+      flowOrder.delete(0, flowOrder.length);
+    }
+    const flowBlockIndex = yDoc.getMap("qi.flow.blockIndex");
+    flowBlockIndex.forEach((_, key) => flowBlockIndex.delete(key));
+  });
+}
+function hydrateYDocFromMergeResult(yDoc, mergeResult) {
+  const { merged, added, replaced } = mergeResult;
+  yDoc.transact(() => {
+    const flowMeta = yDoc.getMap("qi.flow.meta");
+    for (const [key, value] of Object.entries(merged.meta)) {
+      if (value !== void 0) {
+        flowMeta.set(key, value);
+      }
+    }
+    const draftRevision = nextDraftRevision(yDoc, flowMeta.get("draftRevision"));
+    flowMeta.set("draftSchemaVersion", 1);
+    flowMeta.set("draftRevision", draftRevision);
+    const flowNodes = yDoc.getMap("qi.flow.nodes");
+    for (const nodeId of replaced) {
+      flowNodes.delete(nodeId);
+      flowNodes.set(nodeId, createYMapFromNode(merged.nodes[nodeId]));
+    }
+    for (const nodeId of added) {
+      flowNodes.set(nodeId, createYMapFromNode(merged.nodes[nodeId]));
+    }
+    const flowEdges = yDoc.getMap("qi.flow.edges");
+    flowEdges.forEach((_, key) => flowEdges.delete(key));
+    for (const edge of merged.edges) {
+      const yEdge = new Y2.Map();
+      yEdge.set("id", edge.id);
+      yEdge.set("source", edge.source);
+      yEdge.set("target", edge.target);
+      yEdge.set("kind", edge.kind);
+      if (edge.condition) yEdge.set("condition", edge.condition);
+      flowEdges.set(edge.id, yEdge);
+    }
+    const flowOrder = yDoc.getArray("qi.flow.order");
+    if (flowOrder.length > 0) {
+      flowOrder.delete(0, flowOrder.length);
+    }
+    for (const nodeId of merged.order) {
+      flowOrder.push([nodeId]);
+    }
+    const flowBlockIndex = yDoc.getMap("qi.flow.blockIndex");
+    for (const nodeId of [...added, ...replaced]) {
+      flowBlockIndex.set(nodeId, merged.blockIndex[nodeId]);
+    }
+    writeExecutionMeta(yDoc);
+  });
+}
+function initializeRuntime(yDoc, compiled, runId) {
+  const resolvedRunId = runId ?? resolveActiveRunId(yDoc);
+  if (!resolvedRunId) return;
+  yDoc.transact(() => {
+    for (const nodeId of compiled.order) {
+      const blockId = compiled.blockIndex[nodeId];
+      if (blockId) resetActionState(yDoc, resolvedRunId, blockId);
+    }
+  });
+}
+function initializeRuntimeForNodes(yDoc, compiled, nodeIds, runId) {
+  const resolvedRunId = runId ?? resolveActiveRunId(yDoc);
+  if (!resolvedRunId) return;
+  yDoc.transact(() => {
+    for (const nodeId of nodeIds) {
+      const blockId = compiled.blockIndex[nodeId];
+      if (blockId) resetActionState(yDoc, resolvedRunId, blockId);
+    }
+  });
+}
+function createYMapFromNode(node) {
+  const yNode = new Y2.Map();
+  yNode.set("id", node.id);
+  yNode.set("blockId", node.blockId);
+  yNode.set("can", node.can);
+  yNode.set("with", node.with);
+  yNode.set("registryType", node.registryType);
+  yNode.set("executionOwner", getAction(node.registryType)?.executionOwner ?? "agent");
+  yNode.set("title", node.title);
+  yNode.set("description", node.description);
+  yNode.set("props", { ...node.props });
+  const contract = executionContract(node);
+  if (contract) yNode.set("actionContract", contract);
+  if (node.phase) yNode.set("phase", node.phase);
+  if (node.parallelGroup) yNode.set("parallelGroup", node.parallelGroup);
+  if (node.actor) yNode.set("actor", node.actor);
+  return yNode;
+}
+
+// src/core/lib/flowCompiler/documentFragment.ts
+import * as Y3 from "yjs";
+function writeCompiledBlocksToFragment(fragment, blocks) {
+  const documentBlockGroup = getOrCreateDocumentBlockGroup(fragment);
+  for (const block of blocks) {
+    appendBlockToGroup(documentBlockGroup, block);
+  }
+}
+function insertCompiledBlockIntoFragment(fragment, block, beforeBlockId) {
+  const blockGroup = getOrCreateDocumentBlockGroup(fragment);
+  if (beforeBlockId) {
+    for (let index = 0; index < blockGroup.length; index += 1) {
+      const candidate = blockGroup.get(index);
+      if (isYXmlElementLike(candidate) && candidate.getAttribute("id") === beforeBlockId) {
+        blockGroup.insert(index, [createBlockContainer(block)]);
+        return;
+      }
+    }
+  }
+  appendBlockToGroup(blockGroup, block);
+}
+function removeAllFlowBlocks(fragment) {
+  const blockGroup = getExistingBlockGroup(fragment);
+  if (!blockGroup) return;
+  while (blockGroup.length > 0) {
+    blockGroup.delete(0, 1);
+  }
+}
+function removeBlockFromFragment(fragment, blockId) {
+  const blockGroup = getExistingBlockGroup(fragment);
+  if (!blockGroup) return false;
+  for (let i = 0; i < blockGroup.length; i++) {
+    const container = blockGroup.get(i);
+    if (isYXmlElementLike(container) && container.getAttribute("id") === blockId) {
+      blockGroup.delete(i, 1);
+      return true;
+    }
+  }
+  return false;
+}
+function replaceBlockInFragment(fragment, block) {
+  const blockGroup = getExistingBlockGroup(fragment);
+  if (!blockGroup) return false;
+  for (let i = 0; i < blockGroup.length; i++) {
+    const container = blockGroup.get(i);
+    if (isYXmlElementLike(container) && container.getAttribute("id") === block.id) {
+      blockGroup.delete(i, 1);
+      const newContainer = createBlockContainer(block);
+      blockGroup.insert(i, [newContainer]);
+      return true;
+    }
+  }
+  return false;
+}
+function swapBlocksInFragment(fragment, idA, idB) {
+  const blockGroup = getExistingBlockGroup(fragment);
+  if (!blockGroup) return false;
+  let ia = -1;
+  let ib = -1;
+  for (let i = 0; i < blockGroup.length; i++) {
+    const container = blockGroup.get(i);
+    if (isYXmlElementLike(container)) {
+      const id = container.getAttribute("id");
+      if (id === idA) ia = i;
+      else if (id === idB) ib = i;
+    }
+  }
+  if (ia < 0 || ib < 0 || ia === ib) return false;
+  const lo = Math.min(ia, ib);
+  const hi = Math.max(ia, ib);
+  const loClone = blockGroup.get(lo).clone();
+  const hiClone = blockGroup.get(hi).clone();
+  blockGroup.delete(hi, 1);
+  blockGroup.insert(hi, [loClone]);
+  blockGroup.delete(lo, 1);
+  blockGroup.insert(lo, [hiClone]);
+  return true;
+}
+function applyMergeResultToFragment(fragment, mergeResult) {
+  const documentBlockGroup = getOrCreateDocumentBlockGroup(fragment);
+  const blockByNodeId = /* @__PURE__ */ new Map();
+  for (const block of mergeResult.merged.blocks) {
+    for (const [nodeId, blockId] of Object.entries(mergeResult.merged.blockIndex)) {
+      if (blockId === block.id) {
+        blockByNodeId.set(nodeId, block);
+        break;
+      }
+    }
+  }
+  for (const nodeId of mergeResult.replaced) {
+    const block = blockByNodeId.get(nodeId);
+    if (block) {
+      replaceBlockInFragment(fragment, block);
+    }
+  }
+  for (const nodeId of mergeResult.added) {
+    const block = blockByNodeId.get(nodeId);
+    if (block) {
+      appendBlockToGroup(documentBlockGroup, block);
+    }
+  }
+}
+function readBlocksFromFragment(fragment) {
+  const blockGroup = getExistingBlockGroup(fragment);
+  if (!blockGroup) return [];
+  const blocks = [];
+  for (let i = 0; i < blockGroup.length; i++) {
+    const container = blockGroup.get(i);
+    if (!isYXmlElementLike(container) || container.nodeName !== "blockContainer") continue;
+    const id = container.getAttribute("id");
+    if (typeof id !== "string" || id.length === 0) continue;
+    const content = container.get(0);
+    if (!isYXmlElementLike(content)) continue;
+    const props = { ...content.getAttributes() };
+    const textColor = container.getAttribute("textColor");
+    if (typeof textColor === "string" && textColor !== "default") props.textColor = textColor;
+    const backgroundColor = container.getAttribute("backgroundColor");
+    if (typeof backgroundColor === "string" && backgroundColor !== "default") props.backgroundColor = backgroundColor;
+    blocks.push({ id, type: content.nodeName, props });
+  }
+  return blocks;
+}
+function createBlockContainer(block) {
+  const blockContainer = new Y3.XmlElement("blockContainer");
+  const { backgroundColor: rawBackgroundColor, textColor: rawTextColor, ...contentProps } = block.props;
+  blockContainer.setAttribute("id", block.id);
+  blockContainer.setAttribute("textColor", rawTextColor || "default");
+  blockContainer.setAttribute("backgroundColor", rawBackgroundColor || "default");
+  const blockContent = new Y3.XmlElement(block.type);
+  for (const [key, value] of Object.entries(contentProps)) {
+    if (value !== "") {
+      blockContent.setAttribute(key, value);
+    }
+  }
+  blockContainer.insert(0, [blockContent]);
+  return blockContainer;
+}
+function appendBlockToGroup(blockGroup, block) {
+  const container = createBlockContainer(block);
+  blockGroup.insert(blockGroup.length, [container]);
+}
+function getOrCreateDocumentBlockGroup(fragment) {
+  if (fragment.length === 0) {
+    const blockGroup = new Y3.XmlElement("blockGroup");
+    fragment.insert(0, [blockGroup]);
+    return blockGroup;
+  }
+  if (fragment.length === 1) {
+    const rootNode = fragment.get(0);
+    if (isYXmlElementLike(rootNode) && rootNode.nodeName === "blockGroup") {
+      return rootNode;
+    }
+  }
+  throw new Error("Unexpected BlockNote document shape in XmlFragment. Expected a single top-level blockGroup node.");
+}
+function getExistingBlockGroup(fragment) {
+  if (fragment.length === 0) return null;
+  if (fragment.length === 1) {
+    const rootNode = fragment.get(0);
+    if (isYXmlElementLike(rootNode) && rootNode.nodeName === "blockGroup") {
+      return rootNode;
+    }
+  }
+  return null;
+}
+
+// src/core/lib/flowCompiler/readFlow.ts
+function readCompiledFlowFromYDoc(yDoc) {
+  const flowMeta = yDoc.getMap("qi.flow.meta");
+  const flowNodes = yDoc.getMap("qi.flow.nodes");
+  const nodes = {};
+  flowNodes.forEach((value, nodeId) => {
+    if (isYMapLike(value)) {
+      nodes[nodeId] = yMapToFlowNode(value);
+    }
+  });
+  if (flowNodes.size === 0 && flowMeta.size === 0) {
+    return null;
+  }
+  const meta = {
+    flowId: flowMeta.get("flowId") || "",
+    title: flowMeta.get("title") || "",
+    goal: flowMeta.get("goal"),
+    version: flowMeta.get("version") || "",
+    flowOwnerDid: flowMeta.get("flowOwnerDid") || "",
+    flowUri: flowMeta.get("flowUri"),
+    compiledAt: flowMeta.get("compiledAt") || "",
+    compiledFrom: "BaseUcanFlow"
+  };
+  const flowEdges = yDoc.getMap("qi.flow.edges");
+  const edges = [];
+  flowEdges.forEach((value) => {
+    if (isYMapLike(value)) {
+      edges.push(yMapToEdge(value));
+    }
+  });
+  const flowOrder = yDoc.getArray("qi.flow.order");
+  const order = flowOrder.toArray();
+  const flowBlockIndex = yDoc.getMap("qi.flow.blockIndex");
+  const blockIndex = {};
+  flowBlockIndex.forEach((value, key) => {
+    blockIndex[key] = value;
+  });
+  const blocks = order.filter((nodeId) => nodes[nodeId]).map((nodeId) => {
+    const node = nodes[nodeId];
+    return {
+      id: node.blockId,
+      type: COMPILED_BLOCK_TYPE,
+      props: { ...node.props }
+    };
+  });
+  return { meta, blocks, nodes, edges, order, blockIndex };
+}
+function yMapToFlowNode(yMap) {
+  return {
+    id: yMap.get("id") || "",
+    blockId: yMap.get("blockId") || "",
+    can: yMap.get("can") || "",
+    with: yMap.get("with") || "",
+    registryType: yMap.get("registryType") || "",
+    title: yMap.get("title") || "",
+    description: yMap.get("description") || "",
+    props: yMap.get("props") || {},
+    phase: yMap.get("phase"),
+    parallelGroup: yMap.get("parallelGroup"),
+    actor: yMap.get("actor")
+  };
+}
+function yMapToEdge(yMap) {
+  return {
+    id: yMap.get("id") || "",
+    source: yMap.get("source") || "",
+    target: yMap.get("target") || "",
+    // Only 'trigger' edges exist. Legacy 'dependency' edges from older
+    // Y.Docs (before dependsOn was removed) get coerced — they'll be
+    // overwritten on the next compile pass.
+    kind: "trigger",
+    condition: yMap.get("condition")
+  };
+}
+
+// src/core/lib/flowCompiler/mergeFlows.ts
+function mergeCompiledFlows(existing, incoming, strategy) {
+  const added = [];
+  const replaced = [];
+  const kept = [];
+  const mergedNodes = {};
+  const mergedBlockIndex = {};
+  for (const [nodeId, node] of Object.entries(existing.nodes)) {
+    mergedNodes[nodeId] = node;
+    mergedBlockIndex[nodeId] = existing.blockIndex[nodeId];
+  }
+  for (const [nodeId, node] of Object.entries(incoming.nodes)) {
+    if (mergedNodes[nodeId]) {
+      if (strategy === "patch") {
+        mergedNodes[nodeId] = node;
+        mergedBlockIndex[nodeId] = incoming.blockIndex[nodeId];
+        replaced.push(nodeId);
+      } else {
+        kept.push(nodeId);
+      }
+    } else {
+      mergedNodes[nodeId] = node;
+      mergedBlockIndex[nodeId] = incoming.blockIndex[nodeId];
+      added.push(nodeId);
+    }
+  }
+  for (const nodeId of Object.keys(existing.nodes)) {
+    if (!replaced.includes(nodeId)) {
+      kept.push(nodeId);
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of [...existing.edges, ...incoming.edges]) {
+    if (mergedNodes[edge.source] && mergedNodes[edge.target]) {
+      edgeMap.set(edge.id, edge);
+    }
+  }
+  const edges = Array.from(edgeMap.values());
+  const order = Object.keys(mergedNodes);
+  const blocks = order.map((nodeId) => {
+    const node = mergedNodes[nodeId];
+    return {
+      id: node.blockId,
+      type: COMPILED_BLOCK_TYPE,
+      props: { ...node.props }
+    };
+  });
+  const meta = {
+    ...incoming.meta,
+    flowId: existing.meta.flowId,
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    merged: { meta, blocks, nodes: mergedNodes, edges, order, blockIndex: mergedBlockIndex },
+    added,
+    replaced,
+    kept
+  };
+}
+
+// src/core/lib/flowCompiler/decompile.ts
+function decompileToBaseUcanFlow(compiled) {
+  const nodeIdByBlockId = {};
+  for (const [nodeId, blockId] of Object.entries(compiled.blockIndex)) {
+    nodeIdByBlockId[blockId] = nodeId;
+  }
+  const capabilities = compiled.order.map((nodeId) => {
+    const node = compiled.nodes[nodeId];
+    return nodeToCapability(node, nodeIdByBlockId);
+  });
+  return {
+    kind: "qi.flow.base-ucan",
+    version: "1.0",
+    flowId: compiled.meta.flowId,
+    title: compiled.meta.title,
+    goal: compiled.meta.goal,
+    meta: {
+      rootIssuer: compiled.meta.flowOwnerDid || void 0,
+      flowUri: compiled.meta.flowUri
+    },
+    capabilities
+  };
+}
+function nodeToCapability(node, nodeIdByBlockId) {
+  const cap = {
+    id: node.id,
+    can: node.can,
+    with: node.with
+  };
+  if (node.props.inputs) {
+    try {
+      const nb = JSON.parse(node.props.inputs);
+      if (nb && typeof nb === "object" && Object.keys(nb).length > 0) {
+        cap.nb = nb;
+      }
+    } catch {
+    }
+  }
+  if (node.parallelGroup) {
+    cap.parallelGroup = node.parallelGroup;
+  }
+  if (node.phase) {
+    cap.phase = node.phase;
+  }
+  if (node.actor) {
+    cap.actor = { ...node.actor };
+  }
+  const ttl = {};
+  if (node.props.ttlAbsoluteDueDate) ttl.absoluteDueDate = node.props.ttlAbsoluteDueDate;
+  if (node.props.ttlFromEnablement) ttl.fromEnablement = node.props.ttlFromEnablement;
+  if (node.props.ttlFromCommitment) ttl.fromCommitment = node.props.ttlFromCommitment;
+  if (Object.keys(ttl).length > 0) {
+    cap.ttl = ttl;
+  }
+  if (typeof node.props.trigger === "string" && node.props.trigger.length > 0) {
+    try {
+      const trigger = JSON.parse(node.props.trigger);
+      if (trigger && typeof trigger === "object" && typeof trigger.type === "string") {
+        cap.trigger = triggerToNodeIds(trigger, nodeIdByBlockId);
+      }
+    } catch {
+    }
+  }
+  if (node.title && node.title !== node.can) {
+    cap.title = node.title;
+  }
+  if (node.description) {
+    cap.description = node.description;
+  }
+  if (node.props.icon) {
+    cap.icon = node.props.icon;
+  }
+  return cap;
+}
+function triggerToNodeIds(trigger, nodeIdByBlockId) {
+  if (trigger.type === "block.event" && trigger.sourceBlockId) {
+    return { ...trigger, sourceBlockId: nodeIdByBlockId[trigger.sourceBlockId] ?? trigger.sourceBlockId };
+  }
+  if (trigger.type === "block.event.all" && trigger.sources) {
+    return {
+      ...trigger,
+      sources: trigger.sources.map((src) => ({ ...src, sourceBlockId: nodeIdByBlockId[src.sourceBlockId] ?? src.sourceBlockId }))
+    };
+  }
+  return trigger;
+}
+
+// src/core/lib/flowCompiler/setup.ts
+import * as Y4 from "yjs";
+import { MatrixProvider as MatrixProvider2 } from "@ixo/matrix-crdt";
+async function readFlowAsBaseUcan(options) {
+  const { roomId, matrixClient } = options;
+  const { yDoc, provider } = await connectToRoom(roomId, matrixClient, { adoptRuns: false });
+  try {
+    const compiled = readCompiledFlowFromYDoc(yDoc);
+    if (!compiled) return null;
+    const plan = decompileToBaseUcanFlow(compiled);
+    return { plan, compiled, roomId };
+  } finally {
+    provider.dispose();
+    yDoc.destroy();
+  }
+}
+function readFlowFromEditor(editor) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return null;
+  const compiled = readCompiledFlowFromYDoc(yDoc);
+  if (!compiled) return null;
+  const plan = decompileToBaseUcanFlow(compiled);
+  const roomId = editor.getRoomId?.() || "";
+  return { plan, compiled, roomId };
+}
+var activeEditor = null;
+function setActiveEditor(editor) {
+  activeEditor = editor;
+}
+function getActiveEditor() {
+  return activeEditor;
+}
+function readFlow() {
+  if (!activeEditor) {
+    console.warn("[readFlow] No active editor registered. Did the editor finish mounting?");
+    return null;
+  }
+  return readFlowFromEditor(activeEditor);
+}
+async function setupFlowFromBaseUcan(options) {
+  const { plan: rawPlan, roomId, matrixClient, creatorDid, docId, templateId, strategy = "full" } = options;
+  const identified = rawPlan.flowId ? rawPlan : { ...rawPlan, flowId: docId || roomId };
+  const plan = templateId ? stripActiveScheduleBindings(identified) : identified;
+  const incomingCompiled = compileBaseUcanFlow(plan, { getActionByCan });
+  const { yDoc, provider } = await connectToRoom(roomId, matrixClient, { adoptRuns: true });
+  let finalCompiled;
+  try {
+    finalCompiled = applyFlowPlanToYDoc(yDoc, { plan, incomingCompiled, creatorDid, docId, templateId, strategy });
+    await provider.waitForFlush();
+  } finally {
+    provider.dispose();
+    yDoc.destroy();
+  }
+  return {
+    compiled: finalCompiled,
+    roomId,
+    flowId: plan.flowId
+  };
+}
+async function seedDesignPodTemplateFlow(options) {
+  const { methodId, roomId, matrixClient, creatorDid } = options;
+  const rawPlan = createDesignPodPortalJourneyPlan(methodId);
+  const plan = rawPlan.flowId ? rawPlan : { ...rawPlan, flowId: roomId };
+  const incomingCompiled = compileBaseUcanFlow(plan, { getActionByCan });
+  const { yDoc, provider } = await connectToRoom(roomId, matrixClient, { adoptRuns: true });
+  let finalCompiled;
+  try {
+    finalCompiled = applyFlowPlanToYDoc(yDoc, { plan, incomingCompiled, creatorDid, strategy: "full" });
+    seedDesignPodMethodDefinition(yDoc, methodId);
+    await provider.waitForFlush();
+  } finally {
+    provider.dispose();
+    yDoc.destroy();
+  }
+  return { compiled: finalCompiled, roomId, flowId: plan.flowId };
+}
+function applyFlowPlanToYDoc(yDoc, options) {
+  const { plan, incomingCompiled, creatorDid, docId, templateId, strategy, runId } = options;
+  const root = yDoc.getMap("root");
+  const fragment = yDoc.getXmlFragment("document");
+  const existingFlow = readCompiledFlowFromYDoc(yDoc);
+  if (strategy === "full") {
+    if (existingFlow) {
+      clearFlowState(yDoc);
+      removeAllFlowBlocks(fragment);
+    }
+    setRootMetadata(yDoc, root, plan, creatorDid, docId, templateId);
+    hydrateYDocFromCompiledFlow(yDoc, incomingCompiled);
+    if (!existingFlow) {
+      initializeRuntime(yDoc, incomingCompiled, runId);
+    }
+    yDoc.transact(() => {
+      writeCompiledBlocksToFragment(fragment, incomingCompiled.blocks);
+    });
+    return incomingCompiled;
+  }
+  if (!existingFlow) {
+    setRootMetadata(yDoc, root, plan, creatorDid, docId, templateId);
+    hydrateYDocFromCompiledFlow(yDoc, incomingCompiled);
+    initializeRuntime(yDoc, incomingCompiled, runId);
+    yDoc.transact(() => {
+      writeCompiledBlocksToFragment(fragment, incomingCompiled.blocks);
+    });
+    return incomingCompiled;
+  }
+  const mergeResult = mergeCompiledFlows(existingFlow, incomingCompiled, strategy);
+  hydrateYDocFromMergeResult(yDoc, mergeResult);
+  const nodesToInit = [...mergeResult.added, ...mergeResult.replaced];
+  initializeRuntimeForNodes(yDoc, mergeResult.merged, nodesToInit, runId);
+  yDoc.transact(() => {
+    applyMergeResultToFragment(fragment, mergeResult);
+  });
+  return mergeResult.merged;
+}
+async function connectToRoom(roomId, matrixClient, options) {
+  const yDoc = new Y4.Doc();
+  const client = matrixClient;
+  client.canSupportVoip = false;
+  client.clientOpts = { lazyLoadMembers: true };
+  const provider = new MatrixProvider2(
+    yDoc,
+    client,
+    { type: "id", id: roomId },
+    {
+      translator: {
+        updateEventType: "matrix-crdt.doc_update",
+        snapshotEventType: "matrix-crdt.doc_snapshot",
+        enableMediaSnapshots: true
+      },
+      enableExperimentalWebrtcSync: false,
+      enableAwareness: false,
+      reader: { snapshotInterval: 10 },
+      writer: { flushInterval: 300, retryIfForbiddenInterval: 3e4 }
+    }
+  );
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timed out connecting to room ${roomId}`));
+    }, 3e4);
+    provider.onDocumentAvailable(() => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    provider.onDocumentUnavailable(() => {
+      clearTimeout(timeout);
+      reject(new Error(`Room ${roomId} is unavailable`));
+    });
+    provider.initialize().catch((err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+  if (options.adoptRuns && provider.canWrite) {
+    collectPhantomLegacyRun(yDoc);
+  }
+  return { yDoc, provider };
+}
+function setRootMetadata(yDoc, root, plan, creatorDid, docId, templateId) {
+  yDoc.transact(() => {
+    if (!root.get("@context")) root.set("@context", "https://ixo.world/flow/0.3");
+    if (!root.get("_type")) root.set("_type", "ixo.flow.crdt");
+    if (!root.get("schema_version")) root.set("schema_version", "0.3");
+    if (!root.get("doc_id")) root.set("doc_id", docId || plan.flowId);
+    if (!root.get("createdAt")) root.set("createdAt", (/* @__PURE__ */ new Date()).toISOString());
+    if (!root.get("createdBy")) root.set("createdBy", creatorDid);
+    root.set("flowOwnerDid", creatorDid);
+    if (!hasLegacyRuntimeHistory(yDoc)) setMultiRunStorage(yDoc);
+    if (templateId && !root.get("source_template_id")) {
+      root.set("source_template_id", templateId);
+    }
+    const titleText = yDoc.getText("title");
+    if (titleText.length === 0 && plan.title) {
+      titleText.insert(0, plan.title);
+    }
+  });
+}
+
+// src/core/lib/flowCompiler/authoring.ts
+function readFlowDocument(yDoc, runId) {
+  const compiled = readCompiledFlowFromYDoc(yDoc);
+  if (!compiled) return null;
+  const propsByBlockId = /* @__PURE__ */ new Map();
+  for (const block of readBlocksFromFragment(yDoc.getXmlFragment("document"))) {
+    propsByBlockId.set(block.id, block.props);
+  }
+  const resolvedRunId = resolveRunIdForRead(yDoc, runId);
+  const nodePropsAreAuthoritative = yDoc.getMap("qi.flow.meta").get("draftSchemaVersion") === 1;
+  const nodes = compiled.order.filter((nodeId) => compiled.nodes[nodeId]).map((nodeId) => {
+    const node = compiled.nodes[nodeId];
+    const projectedProps = propsByBlockId.get(node.blockId) ?? {};
+    const props = nodePropsAreAuthoritative && Object.keys(node.props ?? {}).length > 0 ? { ...node.props } : projectedProps;
+    const runtime = resolvedRunId ? readActionState(yDoc, resolvedRunId, node.blockId) : {};
+    return {
+      nodeId,
+      blockId: node.blockId,
+      can: node.can,
+      with: node.with,
+      title: props.title ?? node.title,
+      description: props.description ?? node.description,
+      props,
+      runtime
+    };
+  });
+  return {
+    meta: compiled.meta,
+    order: compiled.order,
+    edges: compiled.edges,
+    blockIndex: compiled.blockIndex,
+    nodes
+  };
+}
+function addFlowNode(yDoc, opts) {
+  const action = getAction(opts.type);
+  if (!action) return null;
+  const nodeId = opts.nodeId ?? `node_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const blockId = opts.blockId ?? `flow_block_${nodeId}`;
+  if (yDoc.getMap("qi.flow.nodes").has(nodeId) || [...yDoc.getMap("qi.flow.blockIndex").values()].includes(blockId)) return null;
+  const flowId = yDoc.getMap("qi.flow.meta").get("flowId") || "";
+  const withUri = flowId ? `ixo:flow:${flowId}:${nodeId}` : `ixo:flow:${nodeId}`;
+  const can = action.can ?? "";
+  const title = opts.title || can || action.type;
+  const cap = { id: nodeId, can, with: withUri, title, nb: {} };
+  const props = { ...compileBlockProps(cap, action.type), triggerMode: "manual", ...opts.props ?? {} };
+  const node = {
+    id: nodeId,
+    blockId,
+    can,
+    with: withUri,
+    registryType: action.type,
+    title,
+    description: "",
+    props
+  };
+  yDoc.transact(() => {
+    writeCompiledBlocksToFragment(yDoc.getXmlFragment("document"), [{ id: blockId, type: COMPILED_BLOCK_TYPE, props }]);
+    yDoc.getMap("qi.flow.nodes").set(nodeId, createYMapFromNode(node));
+    yDoc.getMap("qi.flow.blockIndex").set(nodeId, blockId);
+    const order = yDoc.getArray("qi.flow.order");
+    if (opts.afterNodeId) {
+      const idx = order.toArray().indexOf(opts.afterNodeId);
+      if (idx >= 0) order.insert(idx + 1, [nodeId]);
+      else order.push([nodeId]);
+    } else {
+      order.push([nodeId]);
+    }
+    advanceDraftRevision(yDoc);
+  });
+  return { nodeId, blockId };
+}
+function setBlockProps(yDoc, blockId, partial) {
+  const fragment = yDoc.getXmlFragment("document");
+  const existing = readBlocksFromFragment(fragment).find((b) => b.id === blockId);
+  if (!existing) return false;
+  const nodeId = findNodeIdForBlock(yDoc, blockId);
+  const node = nodeId ? yDoc.getMap("qi.flow.nodes").get(nodeId) : void 0;
+  const isVNextDraft = yDoc.getMap("qi.flow.meta").get("draftSchemaVersion") === 1;
+  const canonicalProps = isYMapLike(node) ? node.get("props") : void 0;
+  const baseline = isVNextDraft && canonicalProps ? canonicalProps : existing.props;
+  const merged = { ...baseline, ...partial };
+  let ok = false;
+  yDoc.transact(() => {
+    ok = replaceBlockInFragment(fragment, { id: blockId, type: existing.type, props: merged });
+    if (isYMapLike(node)) {
+      node.set("props", { ...merged });
+      if ("title" in partial) node.set("title", merged.title ?? "");
+      if ("description" in partial) node.set("description", merged.description ?? "");
+      if ("authorisedActors" in partial || "parentCapability" in partial) {
+        const actor = actorFromProps(merged);
+        if (actor) node.set("actor", actor);
+        else node.delete("actor");
+      }
+    }
+    advanceDraftRevision(yDoc);
+  });
+  return ok;
+}
+function syncFlowNodePropsFromProjection(yDoc, blockId, partial, legacyBaseline = {}) {
+  const nodeId = findNodeIdForBlock(yDoc, blockId);
+  if (!nodeId) return false;
+  const node = yDoc.getMap("qi.flow.nodes").get(nodeId);
+  if (!isYMapLike(node)) return false;
+  const isVNextDraft = yDoc.getMap("qi.flow.meta").get("draftSchemaVersion") === 1;
+  const projectedBaseline = readBlocksFromFragment(yDoc.getXmlFragment("document")).find((block) => block.id === blockId)?.props;
+  const nodeProps = node.get("props");
+  const baseline = isVNextDraft ? nodeProps ?? legacyBaseline : projectedBaseline ?? legacyBaseline;
+  if (!isVNextDraft && !nodeProps && Object.keys(baseline).length === 0) return false;
+  yDoc.transact(() => {
+    const merged = { ...baseline, ...partial };
+    node.set("props", merged);
+    if ("title" in partial) node.set("title", merged.title ?? "");
+    if ("description" in partial) node.set("description", merged.description ?? "");
+    if ("authorisedActors" in partial || "parentCapability" in partial) {
+      const actor = actorFromProps(merged);
+      if (actor) node.set("actor", actor);
+      else node.delete("actor");
+    }
+    if (isVNextDraft) advanceDraftRevision(yDoc);
+  });
+  return true;
+}
+function auditFlowProjections(yDoc) {
+  const projected = new Map(readBlocksFromFragment(yDoc.getXmlFragment("document")).map((block) => [block.id, block.props]));
+  const drift = [];
+  yDoc.getMap("qi.flow.nodes").forEach((value, nodeId) => {
+    if (!isYMapLike(value)) return;
+    const blockId = String(value.get("blockId") ?? "");
+    const canonical = value.get("props") ?? {};
+    const projection = projected.get(blockId);
+    if (!projection) drift.push({ nodeId, blockId, kind: "missing_block" });
+    else if (stableProps(canonical) !== stableProps(projection)) drift.push({ nodeId, blockId, kind: "props_mismatch" });
+  });
+  return drift.sort((left, right) => left.nodeId.localeCompare(right.nodeId));
+}
+function repairFlowProjections(yDoc) {
+  const before = auditFlowProjections(yDoc);
+  if (before.length === 0) return before;
+  const fragment = yDoc.getXmlFragment("document");
+  const projected = new Map(readBlocksFromFragment(fragment).map((block) => [block.id, block]));
+  const orderedNodeIds = yDoc.getArray("qi.flow.order").toArray();
+  yDoc.transact(() => {
+    for (const item of before) {
+      const node = yDoc.getMap("qi.flow.nodes").get(item.nodeId);
+      if (!isYMapLike(node)) continue;
+      const props = node.get("props") ?? {};
+      const block = projected.get(item.blockId);
+      if (block) {
+        replaceBlockInFragment(fragment, { ...block, props });
+        continue;
+      }
+      const nodeIndex = orderedNodeIds.indexOf(item.nodeId);
+      const nextProjectedBlockId = orderedNodeIds.slice(nodeIndex + 1).find((candidateNodeId) => {
+        const candidate = yDoc.getMap("qi.flow.nodes").get(candidateNodeId);
+        if (!isYMapLike(candidate)) return false;
+        return projected.has(String(candidate.get("blockId") ?? ""));
+      });
+      const nextNode = nextProjectedBlockId ? yDoc.getMap("qi.flow.nodes").get(nextProjectedBlockId) : void 0;
+      const beforeBlockId = isYMapLike(nextNode) ? String(nextNode.get("blockId") ?? "") : void 0;
+      insertCompiledBlockIntoFragment(fragment, { id: item.blockId, type: COMPILED_BLOCK_TYPE, props }, beforeBlockId);
+      projected.set(item.blockId, { id: item.blockId, type: COMPILED_BLOCK_TYPE, props });
+    }
+    yDoc.getMap("qi.flow.projections").set("document", {
+      draftRevision: Number(yDoc.getMap("qi.flow.meta").get("draftRevision") ?? 0),
+      repairedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+  return before;
+}
+function removeFlowNode(yDoc, nodeId, runId) {
+  const doc = readFlowDocument(yDoc, resolveRunIdForRead(yDoc, runId));
+  if (!doc) return { ok: false, referencedBy: [] };
+  const target = doc.nodes.find((n) => n.nodeId === nodeId);
+  if (!target) return { ok: false, referencedBy: [] };
+  const referencedBy = doc.nodes.filter((n) => n.nodeId !== nodeId && nodeReferences(n, nodeId, target.blockId)).map((n) => n.nodeId);
+  if (referencedBy.length > 0) return { ok: false, referencedBy };
+  const blockId = target.blockId;
+  yDoc.transact(() => {
+    removeBlockFromFragment(yDoc.getXmlFragment("document"), blockId);
+    yDoc.getMap("qi.flow.nodes").delete(nodeId);
+    yDoc.getMap("qi.flow.blockIndex").delete(nodeId);
+    const order = yDoc.getArray("qi.flow.order");
+    const idx = order.toArray().indexOf(nodeId);
+    if (idx >= 0) order.delete(idx, 1);
+    const edges = yDoc.getMap("qi.flow.edges");
+    for (const key of [...edges.keys()]) {
+      const e = edges.get(key);
+      if (isYMapLike(e) && (e.get("source") === nodeId || e.get("target") === nodeId)) edges.delete(key);
+    }
+    advanceDraftRevision(yDoc);
+  });
+  return { ok: true };
+}
+function reorderFlowNodes(yDoc, order) {
+  const orderArr = yDoc.getArray("qi.flow.order");
+  const current = orderArr.toArray();
+  if (order.length !== current.length) return false;
+  if (new Set(order).size !== order.length) return false;
+  const currentSet = new Set(current);
+  if (!order.every((id) => currentSet.has(id))) return false;
+  const blockIndex = yDoc.getMap("qi.flow.blockIndex");
+  const fragment = yDoc.getXmlFragment("document");
+  yDoc.transact(() => {
+    orderArr.delete(0, orderArr.length);
+    orderArr.push(order);
+    if (!fragmentHasContentBlocks(fragment)) {
+      const blocks = readBlocksFromFragment(fragment);
+      const byId = new Map(blocks.map((b) => [b.id, b]));
+      const orderedIds = order.map((nid) => blockIndex.get(nid)).filter((id) => !!id);
+      const ordered = orderedIds.map((id) => byId.get(id)).filter((b) => !!b);
+      const extras = blocks.filter((b) => !orderedIds.includes(b.id));
+      removeAllFlowBlocks(fragment);
+      writeCompiledBlocksToFragment(fragment, [...ordered, ...extras]);
+    }
+    advanceDraftRevision(yDoc);
+  });
+  return true;
+}
+function swapFlowBlocks(yDoc, blockIdA, blockIdB) {
+  const fragment = yDoc.getXmlFragment("document");
+  let ok = false;
+  yDoc.transact(() => {
+    ok = swapBlocksInFragment(fragment, blockIdA, blockIdB);
+    if (!ok) return;
+    const blockIndex = yDoc.getMap("qi.flow.blockIndex");
+    let nodeA;
+    let nodeB;
+    for (const [nodeId, bId] of blockIndex.entries()) {
+      if (bId === blockIdA) nodeA = nodeId;
+      else if (bId === blockIdB) nodeB = nodeId;
+    }
+    if (nodeA && nodeB) {
+      const order = yDoc.getArray("qi.flow.order");
+      const arr = order.toArray();
+      const ia = arr.indexOf(nodeA);
+      const ib = arr.indexOf(nodeB);
+      if (ia >= 0 && ib >= 0) {
+        [arr[ia], arr[ib]] = [arr[ib], arr[ia]];
+        order.delete(0, order.length);
+        order.push(arr);
+      }
+    }
+    advanceDraftRevision(yDoc);
+  });
+  return ok;
+}
+function updateNodeRuntime(yDoc, blockId, partial, runId) {
+  writeActionState(yDoc, resolveRunIdForExecution(yDoc, runId), blockId, partial);
+}
+function resetStepRuntime(yDoc, blockId, runId) {
+  updateNodeRuntime(yDoc, blockId, { state: "idle", error: void 0, output: {} }, runId);
+}
+function setFormAnswers(yDoc, blockId, answers, runId) {
+  const resolvedRunId = resolveRunIdForExecution(yDoc, runId);
+  const base = readActionState(yDoc, resolvedRunId, blockId);
+  const output = base.output && typeof base.output === "object" ? base.output : {};
+  const form = output.form && typeof output.form === "object" ? output.form : {};
+  writeActionState(yDoc, resolvedRunId, blockId, { output: { ...output, form: { ...form, answers: JSON.stringify(answers) } } });
+}
+function safeParseJson(value, fallback) {
+  if (typeof value !== "string" || value.length === 0) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function advanceDraftRevision(yDoc) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  const current = Number(meta.get("draftRevision") ?? 0);
+  if (meta.get("draftSchemaVersion") !== 1) return current;
+  const next = current + 1;
+  meta.set("draftRevision", next);
+  meta.set(
+    "definitionDigest",
+    sha256Digest({
+      nodes: yDoc.getMap("qi.flow.nodes").toJSON(),
+      edges: yDoc.getMap("qi.flow.edges").toJSON(),
+      order: yDoc.getArray("qi.flow.order").toArray()
+    })
+  );
+  meta.set("executionSchemaVersion", 3);
+  meta.set("draftUpdatedAt", (/* @__PURE__ */ new Date()).toISOString());
+  return next;
+}
+function stableProps(props) {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(props).filter(([, value]) => value !== "").sort(([left], [right]) => left.localeCompare(right))
+    )
+  );
+}
+function findNodeIdForBlock(yDoc, blockId) {
+  const blockIndex = yDoc.getMap("qi.flow.blockIndex");
+  for (const [nodeId, bId] of blockIndex.entries()) {
+    if (bId === blockId) return nodeId;
+  }
+  return void 0;
+}
+function actorFromProps(props) {
+  const authorisedActors = safeParseJson(props.authorisedActors, void 0);
+  const parentCapability = props.parentCapability && props.parentCapability.length > 0 ? props.parentCapability : void 0;
+  const hasActors = Array.isArray(authorisedActors) && authorisedActors.length > 0;
+  if (!hasActors && !parentCapability) return void 0;
+  const actor = {};
+  if (hasActors) actor.authorisedActors = authorisedActors;
+  if (parentCapability) actor.parentCapability = parentCapability;
+  return actor;
+}
+function nodeReferences(node, nodeId, blockId) {
+  const trigger = safeParseJson(node.props.trigger, void 0);
+  if (trigger?.sourceBlockId === nodeId || trigger?.sourceBlockId === blockId) return true;
+  if (Array.isArray(trigger?.sources) && trigger.sources.some((s) => s?.sourceBlockId === nodeId || s?.sourceBlockId === blockId)) return true;
+  const cond = safeParseJson(node.props.conditions, void 0);
+  if (Array.isArray(cond?.conditions) && cond.conditions.some((c) => c?.sourceBlockId === blockId)) return true;
+  const inputs = typeof node.props.inputs === "string" ? node.props.inputs : "";
+  if (inputs.includes(`${nodeId}.output`)) return true;
+  return false;
+}
+function fragmentHasContentBlocks(fragment) {
+  if (fragment.length === 0) return false;
+  const root = fragment.get(0);
+  if (!isYXmlElementLike(root) || root.nodeName !== "blockGroup") return false;
+  for (let i = 0; i < root.length; i++) {
+    const container = root.get(i);
+    if (!isYXmlElementLike(container)) continue;
+    const content = container.get(0);
+    if (isYXmlElementLike(content) && content.length > 0) return true;
+  }
+  return false;
+}
+
+// src/core/lib/flowAgent/policy.ts
+var COMMAND_CAPABILITIES = {
+  diagnose_blocker: "flow/observe",
+  assign_actor: "flow/node/assign",
+  notify_actor: "flow/notify",
+  execute_action: "flow/node/execute",
+  validate_external_state: "flow/mutation/execute",
+  archive_flow: "flow/archive",
+  propose_config_change: "flow/config/propose"
+};
+function requiredCapabilityForCommand(type, flowUri, nodeId) {
+  return capabilityForCommand(COMMAND_CAPABILITIES[type], flowUri, nodeId);
+}
+function isCapabilityMatch(granted, required) {
+  return canMatches(granted.can, required.can) && resourceMatches(granted.with, required.with);
+}
+function canMatches(granted, required) {
+  return capabilityPatternCoversCan(granted, required, { allowGlobalWildcard: true });
+}
+function resourceMatches(granted, required) {
+  if (granted === "*" || granted === required) return true;
+  if (granted.endsWith("*")) {
+    const prefix = granted.slice(0, -1);
+    return required.startsWith(prefix);
+  }
+  return false;
+}
+function evaluateFlowAgentPolicy({
+  actorDid,
+  commandType,
+  flowUri,
+  nodeId,
+  delegationStore,
+  delegations,
+  now = Date.now()
+}) {
+  const required = requiredCapabilityForCommand(commandType, flowUri, nodeId);
+  const candidates = delegations || delegationStore?.getByAudience(actorDid) || [];
+  for (const delegation of candidates) {
+    if (delegation.audienceDid !== actorDid) continue;
+    if (delegation.expiration != null && delegation.expiration <= now) continue;
+    if (!delegation.capabilities.some((capability) => isCapabilityMatch(capability, required))) continue;
+    return {
+      allowed: true,
+      reason: "Allowed by UCAN delegation",
+      capability: required,
+      proofCids: [delegation.cid, ...delegation.proofCids]
+    };
+  }
+  return {
+    allowed: false,
+    reason: `Actor ${actorDid} lacks ${required.can} on ${required.with}`,
+    capability: required,
+    proofCids: []
+  };
+}
+
+// src/core/lib/flowAgent/commands.ts
+function createAgentCommand({ type, flowId, sessionRunId, flowUri, nodeId, actor, reason, payload = {}, now = Date.now() }) {
+  const capability = requiredCapabilityForCommand(type, flowUri, nodeId);
+  const id = computeAgentCommandId({ flowId, sessionRunId, nodeId, type, payload });
+  return {
+    id,
+    type,
+    flowId,
+    sessionRunId,
+    flowUri,
+    nodeId,
+    actorDid: actor.did,
+    status: "queued",
+    capability,
+    idempotencyKey: `${id}:${createIntentHash({ capability, payload })}`,
+    createdAt: now,
+    updatedAt: now,
+    reason,
+    payload
+  };
+}
+function validateAgentCommand(command) {
+  if (!command.id) return { valid: false, error: "Command id is required" };
+  if (!command.flowId) return { valid: false, error: "flowId is required" };
+  if (!command.sessionRunId) return { valid: false, error: "sessionRunId is required" };
+  if (!command.flowUri) return { valid: false, error: "flowUri is required" };
+  if (!command.nodeId) return { valid: false, error: "nodeId is required" };
+  if (!command.actorDid) return { valid: false, error: "actorDid is required" };
+  if (!command.capability?.can || !command.capability?.with) return { valid: false, error: "capability is required" };
+  if (!command.idempotencyKey) return { valid: false, error: "idempotencyKey is required" };
+  if (isExternalMutation(command.type) && !command.payload.validator) {
+    return {
+      valid: false,
+      error: `${command.type} requires payload.validator for post-action read-back validation`
+    };
+  }
+  if (command.type === "propose_config_change" && !command.payload.proposal) {
+    return { valid: false, error: "Config changes must be expressed as payload.proposal" };
+  }
+  return { valid: true };
+}
+function isExternalMutation(type) {
+  return type === "validate_external_state";
+}
+
+// src/core/lib/flowAgent/context.ts
+function buildFlowAgentContext({
+  yDoc,
+  flowId,
+  sessionRunId,
+  flowUri = `ixo:flow:${flowId}`,
+  actor,
+  blocks,
+  documentBlocks,
+  editor,
+  now
+}) {
+  return {
+    yDoc,
+    flowId,
+    sessionRunId,
+    flowUri,
+    actor,
+    ...blocks ? { blocks } : {},
+    ...documentBlocks ? { documentBlocks } : {},
+    ...editor ? { editor } : {},
+    ...now ? { now } : {}
+  };
+}
+
+// src/core/lib/flowAgent/lease.ts
+var DEFAULT_FLOW_AGENT_LEASE_TTL_MS = 6e4;
+function acquireFlowAgentLease({
+  leases,
+  commandId,
+  sessionRunId,
+  nodeId,
+  actorDid,
+  now = Date.now(),
+  ttlMs = DEFAULT_FLOW_AGENT_LEASE_TTL_MS
+}) {
+  const current = leases.get(commandId);
+  if (current && current.expiresAt > now && current.actorDid !== actorDid) {
+    return null;
+  }
+  const nextEpoch = current ? current.epoch + 1 : 1;
+  const lease = {
+    id: `${commandId}:lease:${nextEpoch}`,
+    commandId,
+    sessionRunId,
+    nodeId,
+    actorDid,
+    acquiredAt: now,
+    expiresAt: now + ttlMs,
+    epoch: nextEpoch
+  };
+  leases.set(commandId, lease);
+  return lease;
+}
+function validateFlowAgentLease(leases, lease, now = Date.now()) {
+  const current = leases.get(lease.commandId);
+  return !!current && current.actorDid === lease.actorDid && current.epoch === lease.epoch && current.expiresAt > now;
+}
+function releaseFlowAgentLease(leases, lease) {
+  const current = leases.get(lease.commandId);
+  if (!current || current.actorDid !== lease.actorDid || current.epoch !== lease.epoch) return false;
+  leases.delete(lease.commandId);
+  return true;
+}
+function cleanupExpiredFlowAgentLeases(leases, now = Date.now()) {
+  const expired = [];
+  leases.forEach((lease, commandId) => {
+    if (lease.expiresAt <= now) {
+      expired.push(lease);
+      leases.delete(commandId);
+    }
+  });
+  return expired;
+}
+
+// src/core/lib/flowAgent/state.ts
+function classifyBlockerCause(block, runtime) {
+  const props = getBlockProps(block);
+  if (runtime.error?.code === "missing_ucan") return "missing_ucan";
+  if (runtime.error?.code === "validation_mismatch") return "validation_mismatch";
+  if (runtime.error?.code === "external_confirmation_pending") return "external_confirmation_pending";
+  if (runtime.error) return "service_error";
+  const conditions = parseJsonProp(props.conditions, {});
+  if (conditions.enabled && Array.isArray(conditions.conditions) && conditions.conditions.length > 0) {
+    return "failed_upstream";
+  }
+  const inputs = parseJsonProp(props.inputs, {});
+  const requiredInputs = parseJsonProp(props.requiredInputs, []);
+  if (requiredInputs.some((key) => inputs[key] == null || inputs[key] === "")) {
+    return "missing_input";
+  }
+  return void 0;
+}
+function classifyNodeState({ block, runtime, now, pendingInvocationCount = 0, completionVerification }) {
+  const derived = deriveBlockPhase({
+    runtime,
+    actionType: getBlockActionType(block),
+    completionVerification,
+    pendingInvocationCount
+  });
+  if (derived.phase === "failed") return "Blocked";
+  if (derived.phase === "complete") return "Done";
+  if (derived.detail === "standing" && pendingInvocationCount === 0) return "Done";
+  if (runtime.error) return "Blocked";
+  const dueAt = getDueAt(block);
+  if (dueAt != null && dueAt <= now) return "Overdue";
+  return "Pending";
+}
+function snapshotNode(block, runtime, now, pendingInvocationCount = 0, completionVerification) {
+  const nodeId = getBlockId(block);
+  if (!nodeId) {
+    throw new Error("Cannot snapshot a block without an id");
+  }
+  const publicState = classifyNodeState({ block, runtime, now, pendingInvocationCount, completionVerification });
+  const dueAt = getDueAt(block);
+  const assigneeDid = getAssigneeDid(block);
+  const snapshot = {
+    nodeId,
+    blockType: getBlockType(block),
+    runtime,
+    publicState,
+    pendingInvocationCount
+  };
+  const actionType = getBlockActionType(block);
+  if (actionType) snapshot.actionType = actionType;
+  const title = getBlockTitle(block);
+  if (title) snapshot.title = title;
+  if (publicState === "Blocked") {
+    if (runtime.state === "needs_verification") {
+      snapshot.blockerCause = "awaiting_verification";
+    } else {
+      snapshot.blockerCause = classifyBlockerCause(block, runtime) || "unknown";
+    }
+  }
+  if (assigneeDid) snapshot.assigneeDid = assigneeDid;
+  if (dueAt != null) snapshot.dueAt = dueAt;
+  return snapshot;
+}
+
+// src/core/lib/flowAgent/actionExecutionPolicy.ts
+var RUNTIME_INPUT_REQUIRED_ACTIONS = /* @__PURE__ */ new Set(["qi/form.submit", "qi/human.form.submit", "qi/human.checkbox.set", "qi/protocol.select"]);
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function parseStringList(value) {
+  const parsed = parseJsonProp(value, []);
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((item) => typeof item === "string" && item.length > 0);
+}
+function normalizeMode(value) {
+  if (value === "saved-input" || value === "saved_input" || value === "savedInput") return "saved-input";
+  if (value === "runtime-input-required" || value === "runtime_input_required" || value === "runtimeInputRequired") return "runtime-input-required";
+  if (value === "human-only" || value === "human_only" || value === "humanOnly") return "human-only";
+  return void 0;
+}
+function parseExecutionConfig(value) {
+  if (value == null || value === "") return {};
+  if (typeof value === "string") {
+    const directMode = normalizeMode(value);
+    if (directMode) return { mode: directMode };
+  }
+  const parsed = parseJsonProp(value, {});
+  if (!isRecord(parsed)) return {};
+  return {
+    mode: normalizeMode(parsed.mode),
+    requiredRuntimeInputs: parseStringList(parsed.requiredRuntimeInputs)
+  };
+}
+function inferDefaultMode(actionType, requiredRuntimeInputs) {
+  if (requiredRuntimeInputs.length > 0) return "runtime-input-required";
+  if (actionType && RUNTIME_INPUT_REQUIRED_ACTIONS.has(actionType)) return "runtime-input-required";
+  return "saved-input";
+}
+function getFlowAgentActionExecutionPolicy(block) {
+  const props = getBlockProps(block);
+  const actionType = getBlockActionType(block);
+  const config = parseExecutionConfig(props.flowAgentExecution || props.flowAgentExecutionMode || props.agentExecutionMode);
+  const requiredRuntimeInputs = [
+    ...config.requiredRuntimeInputs || [],
+    ...parseStringList(props.requiredRuntimeInputs || props.runtimeRequiredInputs || props.flowAgentRequiredRuntimeInputs)
+  ];
+  return {
+    mode: config.mode || inferDefaultMode(actionType, requiredRuntimeInputs),
+    requiredRuntimeInputs: Array.from(new Set(requiredRuntimeInputs))
+  };
+}
+function getCommandRuntimeInputs(payload) {
+  return isRecord(payload.runtimeInputs) ? payload.runtimeInputs : void 0;
+}
+function validateFlowAgentExecuteActionPayload(block, payload) {
+  const policy = getFlowAgentActionExecutionPolicy(block);
+  if (policy.mode === "human-only") {
+    return {
+      valid: false,
+      mode: policy.mode,
+      missingRuntimeInputs: [],
+      reason: "Action requires human execution and cannot be run by the Flow Agent"
+    };
+  }
+  if (policy.mode !== "runtime-input-required") {
+    return { valid: true, mode: policy.mode, missingRuntimeInputs: [] };
+  }
+  const runtimeInputs = getCommandRuntimeInputs(payload);
+  const missingRuntimeInputs = policy.requiredRuntimeInputs.length > 0 ? policy.requiredRuntimeInputs.filter((key) => runtimeInputs?.[key] == null || runtimeInputs[key] === "") : runtimeInputs ? [] : ["runtimeInputs"];
+  if (missingRuntimeInputs.length > 0) {
+    return {
+      valid: false,
+      mode: policy.mode,
+      missingRuntimeInputs,
+      reason: policy.requiredRuntimeInputs.length > 0 ? `Missing required runtimeInputs: ${missingRuntimeInputs.join(", ")}` : "Action requires runtimeInputs before the Flow Agent can execute it"
+    };
+  }
+  return { valid: true, mode: policy.mode, missingRuntimeInputs: [] };
+}
+
+// src/core/lib/flowAgent/orchestrator.ts
+var BLOCKER_DIAGNOSIS_VERSION = 2;
+function getBlocks(context) {
+  const flattened = [];
+  const visit = (block) => {
+    flattened.push(block);
+    const children = block?.children;
+    if (Array.isArray(children)) children.forEach(visit);
+  };
+  (context.blocks || context.editor?.document || []).forEach(visit);
+  return flattened;
+}
+function getConditionDocument(context) {
+  return context.documentBlocks || context.blocks || context.editor?.document || [];
+}
+function getRuntime(yDoc, sessionRunId, nodeId) {
+  const value = readActionState(yDoc, sessionRunId, nodeId);
+  return value && typeof value === "object" ? value : {};
+}
+function validateInputs(block) {
+  const props = getBlockProps(block);
+  const inputs = parseJsonProp(props.inputs, {});
+  const requiredInputs = parseJsonProp(props.requiredInputs, []);
+  const missing = requiredInputs.filter((key) => inputs[key] == null || inputs[key] === "");
+  if (missing.length > 0) {
+    return { valid: false, reason: `Missing required inputs: ${missing.join(", ")}` };
+  }
+  return { valid: true };
+}
+function chooseActor(block, options) {
+  const props = getBlockProps(block);
+  const actionType = getBlockActionType(block);
+  const requiredSkill = typeof props.requiredSkill === "string" ? props.requiredSkill : actionType;
+  if (!options.candidateActors || options.candidateActors.length === 0) return void 0;
+  if (!requiredSkill) return options.candidateActors[0];
+  return options.candidateActors.find((actor) => actor.skills?.includes(requiredSkill)) || options.candidateActors[0];
+}
+function canQueueCommand(type, nodeId, context, options) {
+  return evaluateFlowAgentPolicy({
+    actorDid: context.actor.did,
+    commandType: type,
+    flowUri: context.flowUri,
+    nodeId,
+    delegationStore: options.delegationStore,
+    delegations: options.delegations,
+    now: context.now?.() || Date.now()
+  }).allowed;
+}
+function safeAppendAgentLedgerEvent(yDoc, event) {
+  try {
+    appendAgentLedgerEvent(yDoc, event);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to append flow-agent ledger event";
+    if (message.includes("Unexpected content type") || message.includes("already been defined with a different constructor")) {
+      return;
+    }
+    throw error;
+  }
+}
+function queueIfAuthorized(context, options, type, nodeId, reason, payload) {
+  const now = context.now?.() || Date.now();
+  const policy = evaluateFlowAgentPolicy({
+    actorDid: context.actor.did,
+    commandType: type,
+    flowUri: context.flowUri,
+    nodeId,
+    delegationStore: options.delegationStore,
+    delegations: options.delegations,
+    now
+  });
+  safeAppendAgentLedgerEvent(context.yDoc, {
+    type: "agent.decision",
+    flowId: context.flowId,
+    sessionRunId: context.sessionRunId,
+    nodeId,
+    actorDid: context.actor.did,
+    timestamp: now,
+    details: {
+      commandType: type,
+      allowed: policy.allowed,
+      reason: policy.reason,
+      capability: policy.capability
+    }
+  });
+  if (!policy.allowed) return null;
+  const command = createAgentCommand({
+    type,
+    flowId: context.flowId,
+    sessionRunId: context.sessionRunId,
+    flowUri: context.flowUri,
+    nodeId,
+    actor: context.actor,
+    reason,
+    payload,
+    now
+  });
+  const validation = validateAgentCommand(command);
+  if (!validation.valid) {
+    safeAppendAgentLedgerEvent(context.yDoc, {
+      type: "agent.validation",
+      flowId: context.flowId,
+      sessionRunId: context.sessionRunId,
+      nodeId,
+      commandId: command.id,
+      actorDid: context.actor.did,
+      timestamp: now,
+      details: { valid: false, error: validation.error }
+    });
+    return null;
+  }
+  return queueAgentCommand(context.yDoc, command).created ? command : null;
+}
+function statusForResult(result) {
+  if (result.status) return result.status;
+  if (!result.success) return "failed";
+  return result.confirmed === false ? "awaiting_readback" : "confirmed";
+}
+function planForSnapshot(context, options, block, snapshot) {
+  const queued = [];
+  const actionType = getBlockActionType(block);
+  if (snapshot.publicState === "Done") {
+    return queued;
+  }
+  if (snapshot.publicState === "Overdue") {
+    const command = queueIfAuthorized(context, options, "notify_actor", snapshot.nodeId, "Action node is overdue", {
+      assigneeDid: snapshot.assigneeDid,
+      dueAt: snapshot.dueAt,
+      severity: "overdue"
+    });
+    if (command) queued.push(command);
+    return queued;
+  }
+  if (snapshot.publicState === "Blocked") {
+    const command = queueIfAuthorized(context, options, "diagnose_blocker", snapshot.nodeId, "Action node is blocked and requires diagnosis", {
+      cause: snapshot.blockerCause || "unknown",
+      error: snapshot.runtime.error,
+      diagnosisVersion: BLOCKER_DIAGNOSIS_VERSION
+    });
+    if (command) queued.push(command);
+    return queued;
+  }
+  const assigneeDid = getAssigneeDid(block);
+  if (!assigneeDid) {
+    const actor = chooseActor(block, options);
+    const command = queueIfAuthorized(context, options, "assign_actor", snapshot.nodeId, "Action node has no assigned actor", {
+      targetActorDid: actor?.did,
+      targetMatrixUserId: actor?.matrixUserId,
+      requiredActionType: actionType
+    });
+    if (command) queued.push(command);
+    return queued;
+  }
+  const inputValidation = validateInputs(block);
+  if (!inputValidation.valid) {
+    const command = queueIfAuthorized(context, options, "diagnose_blocker", snapshot.nodeId, inputValidation.reason || "Action node inputs are not ready", {
+      cause: "missing_input"
+    });
+    if (command) queued.push(command);
+    return queued;
+  }
+  if (actionType && canQueueCommand("execute_action", snapshot.nodeId, context, options)) {
+    const pendingInvocation = readPendingInvocations(context.yDoc, snapshot.nodeId, context.sessionRunId)[0];
+    const payload = {
+      actionType,
+      ...pendingInvocation ? { pendingInvocationId: pendingInvocation.id } : {}
+    };
+    const actionValidation = validateFlowAgentExecuteActionPayload(block, payload);
+    if (!actionValidation.valid) {
+      const commandType = actionValidation.mode === "human-only" ? "notify_actor" : "diagnose_blocker";
+      const command2 = queueIfAuthorized(context, options, commandType, snapshot.nodeId, actionValidation.reason || "Action node cannot be executed by Flow Agent yet", {
+        cause: actionValidation.mode === "runtime-input-required" ? "missing_input" : "unknown",
+        requiredActionType: actionType,
+        requiredRuntimeInputs: actionValidation.missingRuntimeInputs,
+        severity: actionValidation.mode === "human-only" ? "attention" : void 0
+      });
+      if (command2) queued.push(command2);
+      return queued;
+    }
+    const command = queueIfAuthorized(context, options, "execute_action", snapshot.nodeId, "Action node is pending and executable", {
+      ...payload
+    });
+    if (command) queued.push(command);
+    return queued;
+  }
+  const notifyCommand = queueIfAuthorized(context, options, "notify_actor", snapshot.nodeId, "Action node is pending but the Flow Agent cannot execute it", {
+    assigneeDid,
+    requiredActionType: actionType,
+    severity: "attention"
+  });
+  if (notifyCommand) queued.push(notifyCommand);
+  return queued;
+}
+function planRalphLoopCommands(context, options = {}) {
+  const now = context.now?.() || Date.now();
+  const blocks = getBlocks(context);
+  const conditionDocument = getConditionDocument(context);
+  const snapshots = [];
+  const queuedCommands = [];
+  for (const block of blocks) {
+    const nodeId = getBlockId(block);
+    if (!nodeId) continue;
+    const pendingInvocationCount = readPendingInvocations(context.yDoc, nodeId, context.sessionRunId).length;
+    const runtime = getRuntime(context.yDoc, context.sessionRunId, nodeId);
+    const snapshot = snapshotNode(block, runtime, now, pendingInvocationCount);
+    try {
+      const eligibility = evaluateBlockExecutionEligibilityForRun(
+        parseConditionConfigStrict(getBlockProps(block).conditions),
+        conditionDocument,
+        context.yDoc,
+        context.sessionRunId
+      );
+      if (!eligibility.eligible && snapshot.publicState !== "Done") {
+        snapshot.publicState = "Blocked";
+        snapshot.blockerCause = "failed_upstream";
+      }
+    } catch {
+      if (snapshot.publicState !== "Done") {
+        snapshot.publicState = "Blocked";
+        snapshot.blockerCause = "validation_mismatch";
+      }
+    }
+    snapshots.push(snapshot);
+    queuedCommands.push(...planForSnapshot(context, options, block, snapshot));
+  }
+  const flowDone = snapshots.length > 0 && snapshots.every((snapshot) => snapshot.publicState === "Done");
+  if (flowDone && options.archiveWhenDone === true) {
+    const archiveCommand = queueIfAuthorized(context, options, "archive_flow", context.flowId, "All Ralph loop action nodes are done", {
+      restartIfRepeats: true
+    });
+    if (archiveCommand) queuedCommands.push(archiveCommand);
+  }
+  return { snapshots, queuedCommands, flowDone };
+}
+async function callExecutor(command, context, executor) {
+  switch (command.type) {
+    case "execute_action":
+      return executor.executeAction ? executor.executeAction(command, context) : { commandId: command.id, success: false, error: "No executeAction handler configured" };
+    case "assign_actor":
+      return executor.assignActor ? executor.assignActor(command, context) : { commandId: command.id, success: false, error: "No assignActor handler configured" };
+    case "notify_actor":
+      return executor.notifyActor ? executor.notifyActor(command, context) : { commandId: command.id, success: false, error: "No notifyActor handler configured" };
+    case "validate_external_state":
+      return executor.validateExternalState ? executor.validateExternalState(command, context) : { commandId: command.id, success: false, error: "No validateExternalState handler configured" };
+    case "archive_flow":
+      return executor.archiveFlow ? executor.archiveFlow(command, context) : { commandId: command.id, success: false, error: "No archiveFlow handler configured" };
+    case "propose_config_change":
+      return executor.proposeConfigChange ? executor.proposeConfigChange(command, context) : { commandId: command.id, success: false, error: "No proposeConfigChange handler configured" };
+    case "diagnose_blocker":
+      return executor.diagnoseBlocker ? executor.diagnoseBlocker(command, context) : { commandId: command.id, success: false, error: "No diagnoseBlocker handler configured" };
+  }
+}
+async function executeQueuedAgentCommands(context, options = {}) {
+  const executor = options.executor;
+  if (!executor) return [];
+  const now = context.now?.() || Date.now();
+  const { leases } = getFlowAgentMaps(context.yDoc);
+  const results = [];
+  for (const command of readQueuedAgentCommands(context.yDoc, context.sessionRunId)) {
+    const validation = validateAgentCommand(command);
+    if (!validation.valid) {
+      updateAgentCommand(context.yDoc, command.id, { status: "failed", error: validation.error, updatedAt: now });
+      results.push({ commandId: command.id, success: false, error: validation.error });
+      continue;
+    }
+    const policy = evaluateFlowAgentPolicy({
+      actorDid: context.actor.did,
+      commandType: command.type,
+      flowUri: context.flowUri,
+      nodeId: command.nodeId,
+      delegationStore: options.delegationStore,
+      delegations: options.delegations,
+      now
+    });
+    if (!policy.allowed) {
+      updateAgentCommand(context.yDoc, command.id, { status: "skipped", error: policy.reason, updatedAt: now });
+      results.push({ commandId: command.id, success: false, error: policy.reason });
+      continue;
+    }
+    const lease = acquireFlowAgentLease({
+      leases,
+      commandId: command.id,
+      sessionRunId: context.sessionRunId,
+      nodeId: command.nodeId,
+      actorDid: context.actor.did,
+      now,
+      ttlMs: options.leaseTtlMs
+    });
+    if (!lease) {
+      continue;
+    }
+    updateAgentCommand(context.yDoc, command.id, { status: "running", lease, updatedAt: now });
+    try {
+      const result = await callExecutor({ ...command, lease, status: "running" }, context, executor);
+      if (!validateFlowAgentLease(leases, lease, context.now?.() || Date.now())) {
+        const leaseError = "Lease expired or was superseded before command commit";
+        updateAgentCommand(context.yDoc, command.id, { status: "failed", error: leaseError, updatedAt: context.now?.() || Date.now() });
+        results.push({ commandId: command.id, success: false, error: leaseError });
+        continue;
+      }
+      updateAgentCommand(context.yDoc, command.id, {
+        status: statusForResult(result),
+        error: result.error,
+        updatedAt: context.now?.() || Date.now()
+      });
+      safeAppendAgentLedgerEvent(context.yDoc, {
+        type: result.success ? "agent.validation" : "agent.escalation",
+        flowId: context.flowId,
+        sessionRunId: context.sessionRunId,
+        nodeId: command.nodeId,
+        commandId: command.id,
+        actorDid: context.actor.did,
+        timestamp: context.now?.() || Date.now(),
+        details: {
+          success: result.success,
+          confirmed: result.confirmed,
+          output: result.output,
+          error: result.error
+        }
+      });
+      results.push(result);
+    } finally {
+      releaseFlowAgentLease(leases, lease);
+    }
+  }
+  return results;
+}
+async function tickFlowAgent(context, options = {}) {
+  const plan = planRalphLoopCommands(context, options);
+  const executedCommands = await executeQueuedAgentCommands(context, options);
+  return {
+    flowDone: plan.flowDone,
+    snapshots: plan.snapshots,
+    queuedCommands: plan.queuedCommands,
+    executedCommands
+  };
+}
+
+// src/core/lib/flowAgent/execution.ts
+var DEFAULT_SCHEMA_VERSION = "1.0.0";
+function resolveExecutionContext(context) {
+  const sessionRunId = resolveRunIdForExecution(context.yDoc, context.sessionRunId);
+  return sessionRunId === context.sessionRunId ? context : { ...context, sessionRunId };
+}
+function safeAppendAgentLedgerEvent2(yDoc, event) {
+  try {
+    appendAgentLedgerEvent(yDoc, event);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to append flow-agent ledger event";
+    if (message.includes("Unexpected content type") || message.includes("already been defined with a different constructor")) {
+      return;
+    }
+    throw error;
+  }
+}
+function getRuntimeRecord(yDoc, sessionRunId, nodeId) {
+  return readActionState(yDoc, sessionRunId, nodeId);
+}
+function clearRuntimeBlocker(yDoc, sessionRunId, nodeId, updates) {
+  const current = getRuntimeRecord(yDoc, sessionRunId, nodeId);
+  const { state: _state, error: _error, ...rest } = current;
+  resetActionState(yDoc, sessionRunId, nodeId, {
+    ...rest,
+    ...updates
+  });
+}
+function findContextBlock(context, nodeId) {
+  const visit = (blocks) => {
+    for (const entry of blocks) {
+      if (getBlockId(entry) === nodeId && entry && typeof entry === "object") {
+        return entry;
+      }
+      const children = entry?.children;
+      if (Array.isArray(children)) {
+        const found = visit(children);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return visit(context.blocks || context.documentBlocks || context.editor?.document || []);
+}
+function getXmlAttribute(element, key) {
+  return element.getAttribute(key);
+}
+function setXmlAttribute(element, key, value) {
+  element.setAttribute(key, value);
+}
+function isRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isYXmlContainerLike(value) {
+  return value != null && typeof value === "object" && typeof value.toArray === "function";
+}
+function isYXmlElementLike2(value) {
+  return isYXmlContainerLike(value) && typeof value.nodeName === "string" && typeof value.getAttribute === "function" && typeof value.setAttribute === "function";
+}
+function getElementBlockId(element) {
+  const directId = getXmlAttribute(element, "id");
+  if (typeof directId === "string" && directId.length > 0) return directId;
+  const attrs = getXmlAttribute(element, "attrs");
+  const attrsId = isRecord2(attrs) ? attrs.id : void 0;
+  return typeof attrsId === "string" && attrsId.length > 0 ? attrsId : void 0;
+}
+function updateXmlElementProps(element, blockId, propsPatch) {
+  const attrs = getXmlAttribute(element, "attrs");
+  if (isRecord2(attrs)) {
+    const existingProps = isRecord2(attrs.props) ? attrs.props : {};
+    setXmlAttribute(element, "attrs", {
+      ...attrs,
+      id: typeof attrs.id === "string" ? attrs.id : blockId,
+      props: {
+        ...existingProps,
+        ...propsPatch
+      }
+    });
+  }
+  for (const [key, value] of Object.entries(propsPatch)) {
+    element.setAttribute(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+}
+function findXmlElementById(container, blockId) {
+  for (const node of container.toArray()) {
+    if (!isYXmlElementLike2(node)) continue;
+    const id = getElementBlockId(node);
+    if (id === blockId) return node;
+    const nested = findXmlElementById(node, blockId);
+    if (nested) return nested;
+  }
+  return null;
+}
+function updateDocumentBlockProps(yDoc, blockId, propsPatch) {
+  const target = findXmlElementById(yDoc.getXmlFragment("document"), blockId);
+  if (!target) return false;
+  updateXmlElementProps(target, blockId, propsPatch);
+  const content = target.toArray().find((node) => isYXmlElementLike2(node) && node.nodeName !== "blockGroup");
+  if (content) {
+    updateXmlElementProps(content, blockId, propsPatch);
+  }
+  return true;
+}
+function assignActorInYDoc(yDoc, command, context) {
+  const targetActorDid = typeof command.payload.targetActorDid === "string" && command.payload.targetActorDid.length > 0 ? command.payload.targetActorDid : context.actor.did;
+  const targetMatrixUserId = typeof command.payload.targetMatrixUserId === "string" ? command.payload.targetMatrixUserId : void 0;
+  const assignment = {
+    assignedActor: {
+      did: targetActorDid,
+      avatar: "",
+      displayName: targetMatrixUserId || targetActorDid
+    },
+    assignedBy: {
+      did: context.actor.did,
+      avatar: "",
+      displayName: context.actor.displayName || context.actor.matrixUserId || ""
+    },
+    assignedTimestamp: new Date(context.now?.() || Date.now()).toISOString()
+  };
+  const assignmentJson = JSON.stringify(assignment);
+  const updatedDocument = updateDocumentBlockProps(yDoc, command.nodeId, {
+    assignment: assignmentJson
+  });
+  if (!updatedDocument) {
+    throw new Error(`Block ${command.nodeId} was not found for assignment`);
+  }
+  const runtime = createYDocRuntimeManager(yDoc, context.sessionRunId);
+  runtime.update(command.nodeId, {
+    assignedActorDid: targetActorDid,
+    assignedByDid: context.actor.did,
+    assignedAt: assignment.assignedTimestamp,
+    lastCommandId: command.id
+  });
+  return assignment;
+}
+async function executeAssignActorCommand(command, context, options) {
+  const capability = { can: "flow/node/assign", with: `${context.flowUri}:${command.nodeId}` };
+  const proofs = await options.ucanService.findValidProofs(context.actor.did, capability);
+  if (!proofs.found || !proofs.proofCids) {
+    return {
+      commandId: command.id,
+      success: false,
+      error: proofs.error || "No valid delegation found for assignment"
+    };
+  }
+  const result = await options.ucanService.executeWithInvocation(
+    {
+      invokerDid: context.actor.did,
+      invokerType: options.actorType,
+      entityRoomId: options.entityRoomId,
+      capability,
+      proofs: proofs.proofCids,
+      pin: options.pin
+    },
+    async () => assignActorInYDoc(context.yDoc, command, context),
+    context.flowId,
+    command.nodeId,
+    context.sessionRunId
+  );
+  return {
+    commandId: command.id,
+    success: result.success,
+    confirmed: result.success,
+    output: result.actionResult && typeof result.actionResult === "object" ? { assignment: result.actionResult, invocationCid: result.invocationCid } : { invocationCid: result.invocationCid },
+    error: result.error
+  };
+}
+async function recoverPendingActionTimeline(command, context, options) {
+  const pendingTimeline = readPendingRunTimelineEvents(context.yDoc, context.sessionRunId, command.nodeId);
+  if (pendingTimeline.length === 0) return void 0;
+  if (!options.runEventLog) {
+    return {
+      commandId: command.id,
+      success: false,
+      confirmed: false,
+      status: "awaiting_readback",
+      error: "Canonical run history is pending and no run event log is available for replay."
+    };
+  }
+  const replay = await retryPendingRunTimelineEvents({
+    yDoc: context.yDoc,
+    sessionRunId: context.sessionRunId,
+    blockId: command.nodeId,
+    eventLog: options.runEventLog,
+    now: options.now || context.now
+  });
+  const current = readActionState(context.yDoc, context.sessionRunId, command.nodeId);
+  const replayedOutput = boundRunActionOutput(current.output || {}).output;
+  const replayStatus = replay.remaining > 0 || current.state === "awaiting_readback" ? "awaiting_readback" : current.state === "completed" ? "confirmed" : "failed";
+  return {
+    commandId: command.id,
+    success: replayStatus === "confirmed",
+    confirmed: replayStatus === "confirmed",
+    status: replayStatus,
+    output: {
+      ...replayedOutput,
+      ...current.lastEventId ? { lastEventId: current.lastEventId } : {},
+      replayedTimelineEvents: replay.attempted,
+      remainingTimelineEvents: replay.remaining
+    },
+    ...replay.remaining > 0 ? { error: "Canonical run history replay remains incomplete." } : replayStatus === "failed" ? {
+      error: current.error?.message || "The action completed in a non-confirmable terminal state."
+    } : {},
+    completionState: current.state === "completed" ? "completed" : current.state === "needs_verification" ? "needs_verification" : current.state === "awaiting_readback" ? "awaiting_readback" : "failed"
+  };
+}
+async function executeActionCommand(command, context, options) {
+  const recoveredTimeline = await recoverPendingActionTimeline(command, context, options);
+  if (recoveredTimeline) return recoveredTimeline;
+  const actionType = typeof command.payload.actionType === "string" ? command.payload.actionType : void 0;
+  if (!actionType) {
+    return { commandId: command.id, success: false, error: "execute_action command is missing payload.actionType" };
+  }
+  const block = findContextBlock(context, command.nodeId);
+  if (!block) {
+    return { commandId: command.id, success: false, error: `Block ${command.nodeId} was not found in runtime context` };
+  }
+  const props = getBlockProps(block);
+  if (typeof props.actionType === "string" && props.actionType !== actionType) {
+    return {
+      commandId: command.id,
+      success: false,
+      error: `execute_action payload.actionType ${actionType} does not match block actionType ${props.actionType}`
+    };
+  }
+  const runtimeInputs = command.payload.runtimeInputs;
+  if (runtimeInputs != null && !isRecord2(runtimeInputs)) {
+    return { commandId: command.id, success: false, error: "execute_action payload.runtimeInputs must be an object when provided" };
+  }
+  const inputValidation = validateFlowAgentExecuteActionPayload(block, command.payload);
+  if (!inputValidation.valid) {
+    return {
+      commandId: command.id,
+      success: false,
+      confirmed: false,
+      status: inputValidation.mode === "human-only" ? "skipped" : "failed",
+      error: inputValidation.reason
+    };
+  }
+  const pendingInvocationId = typeof command.payload.pendingInvocationId === "string" ? command.payload.pendingInvocationId : void 0;
+  const outcome = await executeActionBlock({
+    editorOrYDoc: context.editor || context.yDoc,
+    // The SESSION run (runs.ts), not the per-execution audit id. Constant in
+    // Phase A; passed explicitly so the headless path is already shaped for
+    // Phase B run selection instead of falling back to a doc-level default.
+    runId: context.sessionRunId,
+    block,
+    blockId: command.nodeId,
+    document: context.documentBlocks || context.blocks || context.editor?.document || [],
+    actorDid: context.actor.did,
+    actorType: options.actorType,
+    entityRoomId: options.entityRoomId,
+    ucanService: options.ucanService,
+    invocationStore: options.invocationStore,
+    services: options.actionServices || {},
+    handlers: options.actionHandlers,
+    runtimeInputs: getCommandRuntimeInputs(command.payload),
+    pendingInvocationId,
+    pin: options.pin,
+    flowUri: context.flowUri,
+    flowId: context.flowId,
+    flowOwnerDid: options.flowOwnerDid || "",
+    schemaVersion: options.schemaVersion || DEFAULT_SCHEMA_VERSION,
+    runEventLog: options.runEventLog,
+    now: options.now || context.now
+  });
+  const persisted = readActionState(context.yDoc, context.sessionRunId, command.nodeId);
+  const durableOutput = boundRunActionOutput(persisted.output || {}).output;
+  const pendingAfterExecution = readPendingRunTimelineEvents(context.yDoc, context.sessionRunId, command.nodeId);
+  const timelinePending = pendingAfterExecution.length > 0;
+  return {
+    commandId: command.id,
+    success: outcome.success,
+    confirmed: !timelinePending && outcome.success && outcome.completionState === "completed",
+    ...timelinePending ? { status: "awaiting_readback" } : {},
+    output: {
+      ...durableOutput,
+      ...persisted.lastEventId ? { lastEventId: persisted.lastEventId } : {},
+      ...outcome.invocationCid ? { invocationCid: outcome.invocationCid } : {},
+      ...outcome.capabilityId ? { capabilityId: outcome.capabilityId } : {},
+      // Execution audit id under both names: `runId` is what flow-manager and
+      // flow-agent read today (deprecated), `executionId` is the forward name.
+      ...outcome.runId ? { runId: outcome.runId } : {},
+      ...outcome.executionId ? { executionId: outcome.executionId } : {},
+      ...pendingInvocationId ? { pendingInvocationId, pendingInvocationRemoved: outcome.pendingInvocationRemoved } : {},
+      completionState: outcome.completionState,
+      ...timelinePending ? { remainingTimelineEvents: pendingAfterExecution.length } : {}
+    },
+    error: timelinePending ? "The action effect completed, but canonical run history is pending replay." : outcome.error,
+    completionState: outcome.completionState
+  };
+}
+function getRecoverableBlockerReason(runtime) {
+  const error = runtime.error;
+  const message = error && typeof error === "object" && typeof error.message === "string" ? error.message : typeof error === "string" ? error : void 0;
+  if (!message) return null;
+  if (message.includes("Invalid DID") && message.includes("must start with 'did:'")) {
+    return "matrix_did_normalization";
+  }
+  if (message.includes("Failed to parse URL from undefined")) {
+    return "http_endpoint_input_normalization";
+  }
+  if (message.includes("Unexpected content type") || message.includes("already been defined with a different constructor")) {
+    return "audit_trail_shape";
+  }
+  return null;
+}
+function resetFailedActionCommands(context, nodeId, now) {
+  const { outbox } = getFlowAgentMaps(context.yDoc);
+  const resetIds = [];
+  outbox.forEach((command) => {
+    if (command.sessionRunId !== context.sessionRunId || command.nodeId !== nodeId || command.type !== "execute_action" || command.status !== "failed") {
+      return;
+    }
+    outbox.set(command.id, {
+      ...command,
+      status: "queued",
+      error: void 0,
+      lease: void 0,
+      updatedAt: now,
+      reason: `Retry after blocker diagnosis: ${command.reason}`
+    });
+    resetIds.push(command.id);
+  });
+  return resetIds;
+}
+async function executeDiagnoseBlockerCommand(command, context, options) {
+  const now = options.now?.() || context.now?.() || Date.now();
+  const runtime = getRuntimeRecord(context.yDoc, context.sessionRunId, command.nodeId);
+  const recovery = getRecoverableBlockerReason(runtime);
+  if (!recovery) {
+    return {
+      commandId: command.id,
+      success: true,
+      confirmed: true,
+      output: {
+        blockerCause: command.payload.cause || "unknown",
+        recovery: "manual_intervention_required"
+      }
+    };
+  }
+  clearRuntimeBlocker(context.yDoc, context.sessionRunId, command.nodeId, {
+    diagnosedAt: now,
+    diagnosedByDid: context.actor.did,
+    lastDiagnosisCommandId: command.id,
+    lastRecovery: recovery
+  });
+  const resetCommandIds = resetFailedActionCommands(context, command.nodeId, now);
+  return {
+    commandId: command.id,
+    success: true,
+    confirmed: true,
+    output: {
+      blockerCause: command.payload.cause || "unknown",
+      recovery,
+      resetCommandIds
+    }
+  };
+}
+async function executeFlowAgentCoreCommand(command, context, options) {
+  const executionContext = resolveExecutionContext(context);
+  switch (command.type) {
+    case "assign_actor":
+      return executeAssignActorCommand(command, executionContext, options);
+    case "execute_action":
+      return executeActionCommand(command, executionContext, options);
+    case "diagnose_blocker":
+      return executeDiagnoseBlockerCommand(command, executionContext, options);
+    default:
+      return { commandId: command.id, success: false, error: `No editor-core executor for ${command.type}` };
+  }
+}
+async function callConfiguredExecutor(command, context, options) {
+  if (!options.executor) return void 0;
+  switch (command.type) {
+    case "assign_actor":
+      return options.executor.assignActor?.(command, context);
+    case "execute_action":
+      return options.executor.executeAction?.(command, context);
+    case "notify_actor":
+      return options.executor.notifyActor?.(command, context);
+    case "diagnose_blocker":
+      return options.executor.diagnoseBlocker?.(command, context);
+    default:
+      return void 0;
+  }
+}
+function statusForResult2(result) {
+  if (result.status) return result.status;
+  if (!result.success) return "failed";
+  return result.confirmed === false ? "awaiting_readback" : "confirmed";
+}
+async function executeQueuedFlowAgentCoreCommands(context, options) {
+  context = resolveExecutionContext(context);
+  const now = options.now?.() || context.now?.() || Date.now();
+  const { leases } = getFlowAgentMaps(context.yDoc);
+  const results = [];
+  const queued = readQueuedAgentCommands(context.yDoc, context.sessionRunId);
+  const queuedIds = new Set(queued.map((command) => command.id));
+  const retainedTimelineRecoveries = readAgentCommands(context.yDoc, context.sessionRunId).filter(
+    (command) => command.status === "awaiting_readback" && command.type === "execute_action" && !queuedIds.has(command.id) && readPendingRunTimelineEvents(context.yDoc, context.sessionRunId, command.nodeId).length > 0
+  );
+  for (const command of [...retainedTimelineRecoveries, ...queued]) {
+    if (options.commandTypes && !options.commandTypes.includes(command.type)) {
+      continue;
+    }
+    const validation = validateAgentCommand(command);
+    if (!validation.valid) {
+      updateAgentCommand(context.yDoc, command.id, { status: "failed", error: validation.error, updatedAt: now });
+      results.push({ commandId: command.id, success: false, error: validation.error });
+      continue;
+    }
+    const policy = evaluateFlowAgentPolicy({
+      actorDid: context.actor.did,
+      commandType: command.type,
+      flowUri: context.flowUri,
+      nodeId: command.nodeId,
+      delegationStore: options.delegationStore,
+      delegations: options.delegations,
+      now
+    });
+    if (!policy.allowed) {
+      updateAgentCommand(context.yDoc, command.id, { status: "skipped", error: policy.reason, updatedAt: now });
+      results.push({ commandId: command.id, success: false, error: policy.reason });
+      continue;
+    }
+    const lease = acquireFlowAgentLease({
+      leases,
+      commandId: command.id,
+      sessionRunId: context.sessionRunId,
+      nodeId: command.nodeId,
+      actorDid: context.actor.did,
+      now,
+      ttlMs: options.leaseTtlMs
+    });
+    if (!lease) continue;
+    updateAgentCommand(context.yDoc, command.id, { status: "running", lease, updatedAt: now });
+    try {
+      const runningCommand = { ...command, lease, status: "running" };
+      const result = await Promise.resolve(callConfiguredExecutor(runningCommand, context, options)) || await executeFlowAgentCoreCommand(runningCommand, context, options);
+      const normalized = result || {
+        commandId: command.id,
+        success: false,
+        error: `No executor configured for ${command.type}`
+      };
+      if (!validateFlowAgentLease(leases, lease, options.now?.() || context.now?.() || Date.now())) {
+        const error = "Lease expired or was superseded before command commit";
+        updateAgentCommand(context.yDoc, command.id, { status: "failed", error, updatedAt: options.now?.() || context.now?.() || Date.now() });
+        results.push({ commandId: command.id, success: false, error });
+        continue;
+      }
+      updateAgentCommand(context.yDoc, command.id, {
+        status: statusForResult2(normalized),
+        error: normalized.error,
+        updatedAt: options.now?.() || context.now?.() || Date.now()
+      });
+      safeAppendAgentLedgerEvent2(context.yDoc, {
+        type: normalized.success ? "agent.validation" : "agent.escalation",
+        flowId: context.flowId,
+        sessionRunId: context.sessionRunId,
+        nodeId: command.nodeId,
+        commandId: command.id,
+        actorDid: context.actor.did,
+        timestamp: options.now?.() || context.now?.() || Date.now(),
+        details: {
+          success: normalized.success,
+          confirmed: normalized.confirmed,
+          output: boundRunActionOutput(normalized.output || {}).output,
+          error: normalized.error
+        }
+      });
+      results.push(normalized);
+    } finally {
+      releaseFlowAgentLease(leases, lease);
+    }
+  }
+  return results;
+}
+
+// src/core/lib/flowAgent/service.ts
+var FlowAgentService = class {
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
+    this.timer = null;
+    this.running = false;
+  }
+  async tick() {
+    if (this.running) {
+      return {
+        flowDone: false,
+        snapshots: [],
+        queuedCommands: [],
+        executedCommands: []
+      };
+    }
+    this.running = true;
+    try {
+      const result = await tickFlowAgent(this.context, this.options);
+      await this.options.onTick?.(result);
+      return result;
+    } catch (error) {
+      this.options.onError?.(error);
+      throw error;
+    } finally {
+      this.running = false;
+    }
+  }
+  start() {
+    if (this.timer) return;
+    const intervalMs = this.options.intervalMs || 3e4;
+    this.timer = setInterval(() => {
+      this.tick().catch((error) => {
+        this.options.onError?.(error);
+      });
+    }, intervalMs);
+  }
+  stop() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+};
+
+export {
+  readFlowDocumentHistory,
+  getSharedFlowDocument,
+  toEvaluatorOperator,
+  buildBlockConditionsProp,
+  compileBaseUcanFlow,
+  ACTION_SAFETY_BY_TYPE,
+  resolveActionSafety,
+  ensureFlowExecutionMetadata,
+  adoptLegacyFlowDocument,
+  writeCompiledBlocksToFragment,
+  removeBlockFromFragment,
+  replaceBlockInFragment,
+  readBlocksFromFragment,
+  readCompiledFlowFromYDoc,
+  mergeCompiledFlows,
+  decompileToBaseUcanFlow,
+  readFlowAsBaseUcan,
+  readFlowFromEditor,
+  setActiveEditor,
+  getActiveEditor,
+  readFlow,
+  setupFlowFromBaseUcan,
+  seedDesignPodTemplateFlow,
+  readFlowDocument,
+  addFlowNode,
+  setBlockProps,
+  syncFlowNodePropsFromProjection,
+  auditFlowProjections,
+  repairFlowProjections,
+  removeFlowNode,
+  reorderFlowNodes,
+  swapFlowBlocks,
+  updateNodeRuntime,
+  resetStepRuntime,
+  setFormAnswers,
+  requiredCapabilityForCommand,
+  isCapabilityMatch,
+  canMatches,
+  resourceMatches,
+  evaluateFlowAgentPolicy,
+  createAgentCommand,
+  validateAgentCommand,
+  isExternalMutation,
+  buildFlowAgentContext,
+  acquireFlowAgentLease,
+  validateFlowAgentLease,
+  releaseFlowAgentLease,
+  cleanupExpiredFlowAgentLeases,
+  classifyBlockerCause,
+  classifyNodeState,
+  snapshotNode,
+  planRalphLoopCommands,
+  executeQueuedAgentCommands,
+  tickFlowAgent,
+  executeFlowAgentCoreCommand,
+  executeQueuedFlowAgentCoreCommands,
+  FlowAgentService
+};
+//# sourceMappingURL=chunk-3O42FYT3.js.map