@ixo/editor 5.39.0 → 6.0.0

package/dist/{chunk-YWZJYSOP.js → chunk-5TJK6JKV.js}

@@ -1,5 +1,20 @@
+// src/core/lib/warnOnce.ts
+var seen = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn(message);
+}
+
 // src/core/lib/actionRegistry/registry.ts
 var actions = /* @__PURE__ */ new Map();
+var STEP_COMPLETED_EVENT_NAME = "step.completed";
+var STEP_COMPLETED_EVENT = {
+  name: STEP_COMPLETED_EVENT_NAME,
+  displayName: "Completed",
+  description: "Fires when this step is completed.",
+  payloadSchema: []
+};
 var ACTION_TYPE_ALIASES = {
   bid: "qi/bid.submit",
   claim: "qi/claim.submit",
@@ -40,6 +55,13 @@ function getAction(type) {
 function getAllActions() {
   return Array.from(actions.values());
 }
+function isRepeatableAction(type) {
+  if (!type) return false;
+  return getAction(type)?.cardinality === "many";
+}
+function getAliasEntries() {
+  return Array.from(aliases.entries());
+}
 function hasAction(type) {
   return actions.has(resolveActionType(type));
 }
@@ -51,28 +73,49 @@ function getActionByCan(can) {
 }
 function getEventsForBlock(action, inputs) {
   if (!action) return [];
+  let events;
   if (action.getDynamicEvents) {
     const parsed = normalizeInputs(inputs);
     try {
-      return action.getDynamicEvents(parsed) || [];
-    } catch {
-      return [];
+      const dynamic = action.getDynamicEvents(parsed) || [];
+      events = action.dynamicResolutionMode === "replace" ? dynamic : mergeByKey(action.events || [], dynamic, (event) => event.name);
+    } catch (error) {
+      warnOnce(
+        `dynamic-events:${action.type}`,
+        `[flow-config] action ${action.type}: getDynamicEvents threw (${error instanceof Error ? error.message : String(error)}); no events resolved`
+      );
+      events = [];
     }
+  } else {
+    events = action.events || [];
+  }
+  if (events.some((event) => event.name === STEP_COMPLETED_EVENT_NAME)) {
+    return events;
   }
-  return action.events || [];
+  return [...events, STEP_COMPLETED_EVENT];
 }
 function getOutputSchemaForBlock(action, inputs) {
   if (!action) return [];
   if (action.getDynamicOutputSchema) {
     const parsed = normalizeInputs(inputs);
     try {
-      return action.getDynamicOutputSchema(parsed) || [];
-    } catch {
+      const dynamic = action.getDynamicOutputSchema(parsed) || [];
+      if (action.dynamicResolutionMode === "replace") return dynamic;
+      return mergeByKey(action.outputSchema || [], dynamic, (field) => field.path);
+    } catch (error) {
+      warnOnce(
+        `dynamic-output-schema:${action.type}`,
+        `[flow-config] action ${action.type}: getDynamicOutputSchema threw (${error instanceof Error ? error.message : String(error)}); using static schema`
+      );
       return action.outputSchema || [];
     }
   }
   return action.outputSchema || [];
 }
+function mergeByKey(baseline, dynamic, keyOf) {
+  const dynamicKeys = new Set(dynamic.map(keyOf));
+  return [...baseline.filter((item) => !dynamicKeys.has(keyOf(item))), ...dynamic];
+}
 function normalizeInputs(inputs) {
   if (!inputs) return {};
   if (typeof inputs === "object") return inputs;
@@ -81,12 +124,56 @@ function normalizeInputs(inputs) {
       const parsed = JSON.parse(inputs || "{}");
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
+      warnOnce(`inputs-normalize:${inputs}`, `[flow-config] block inputs are not valid JSON; treated as empty`);
       return {};
     }
   }
   return {};
 }
 
+// src/core/lib/actionRegistry/manifest.ts
+function serializeProof(action) {
+  const proof = action.proof;
+  if (proof === "none" || proof === void 0) return { kind: "none" };
+  if ("validate" in proof) return { kind: "custom" };
+  return { kind: "fields", fields: [...proof.fields] };
+}
+function generateActionManifest() {
+  const aliasEntries = getAliasEntries();
+  const aliasesByType = /* @__PURE__ */ new Map();
+  for (const [alias, canonical] of aliasEntries) {
+    const list = aliasesByType.get(canonical) || [];
+    list.push(alias);
+    aliasesByType.set(canonical, list);
+  }
+  const actions2 = getAllActions().map((action) => {
+    const entry = {
+      type: action.type,
+      aliases: (aliasesByType.get(action.type) || []).sort(),
+      sideEffect: action.sideEffect,
+      defaultRequiresConfirmation: action.defaultRequiresConfirmation,
+      proof: serializeProof(action),
+      hasDynamicEvents: !!action.getDynamicEvents,
+      hasDynamicOutputSchema: !!action.getDynamicOutputSchema,
+      eligibleForEventTrigger: !!action.eligibleForEventTrigger
+    };
+    if (action.can) entry.can = action.can;
+    if (action.requiredCapability) entry.requiredCapability = action.requiredCapability;
+    if (action.inputSchema) entry.inputSchema = action.inputSchema;
+    if (action.outputSchema) entry.outputSchema = action.outputSchema;
+    if (action.events) {
+      entry.events = action.events.map((event) => ({
+        name: event.name,
+        displayName: event.displayName,
+        description: event.description,
+        payloadSchema: event.payloadSchema
+      }));
+    }
+    return entry;
+  }).sort((a, b) => a.type.localeCompare(b.type));
+  return { manifestVersion: "1", actions: actions2 };
+}
+
 // src/core/lib/actionRegistry/canMapping.ts
 var CAN_TO_TYPE = {
   "bid/submit": "qi/bid.submit",
@@ -154,7 +241,37 @@ function getAllCanMappings() {
 }
 
 // src/core/lib/actionRegistry/adapters.ts
+var SERVICE_GROUP_REQUIRED_HANDLERS = {
+  bid: ["submitBid", "approveBid", "rejectBid", "approveServiceAgentApplication", "approveEvaluatorApplication"],
+  claim: ["requestPin", "submitClaim", "evaluateClaim", "getCurrentUser"],
+  collection: [
+    "collection.get",
+    "collection.create",
+    "collection.updateState",
+    "collection.updateDates",
+    "collection.updateQuota",
+    "collection.updatePayments",
+    "collection.updateIntents"
+  ],
+  collectionUsers: ["collectionUsers.grant", "collectionUsers.revoke", "collectionUsers.list", "collectionUsers.classifyAddress", "collectionUsers.enumerateMembers"],
+  carbon: ["carbon.loadBatches", "carbon.harvest", "carbon.retire"]
+};
+function getHandlerAtPath(handlers, path) {
+  return path.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], handlers);
+}
+function warnPartialServiceGroups(handlers) {
+  if (!handlers) return;
+  for (const [group, keys] of Object.entries(SERVICE_GROUP_REQUIRED_HANDLERS)) {
+    const missing = keys.filter((key) => !getHandlerAtPath(handlers, key));
+    if (missing.length > 0 && missing.length < keys.length) {
+      console.warn(
+        `[buildServicesFromHandlers] services.${group} is DISABLED: handlers provide ${keys.length - missing.length}/${keys.length} required methods; missing: ${missing.join(", ")}`
+      );
+    }
+  }
+}
 function buildServicesFromHandlers(handlers) {
+  warnPartialServiceGroups(handlers);
   return {
     http: {
       request: async (params) => {
@@ -362,6 +479,7 @@ registerAction({
   type: "qi/pod.domain-indexer-lookup",
   can: "pod/domain-indexer-lookup",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -401,6 +519,7 @@ registerAction({
   type: "qi/pod.domain-single-selection",
   can: "pod/domain-single-selection",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -455,6 +574,7 @@ registerAction({
   type: "qi/pod.entity-single-selection",
   can: "pod/entity-single-selection",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -513,6 +633,7 @@ registerAction({
   type: "qi/pod.member-multi-select",
   can: "pod/member-multi-select",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -606,6 +727,7 @@ registerAction({
   type: "qi/pod.governance-config",
   can: "pod/governance-config",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -690,6 +812,7 @@ registerAction({
   type: "qi/pod.list-domain-flows",
   can: "pod/list-domain-flows",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -779,6 +902,7 @@ registerAction({
   type: "qi/governance.member-proposal",
   can: "governance/member-proposal",
   sideEffect: true,
+  proof: { fields: ["proposalId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
@@ -794,6 +918,9 @@ registerAction({
     if (!handlers) {
       throw new Error("Handlers not available");
     }
+    if (!handlers.getPreProposalContractAddress || !handlers.getGroupContractAddress || !handlers.getProposalContractAddress || !handlers.createProposal) {
+      throw new Error("Governance proposal handlers not available");
+    }
     const coreAddress = String(inputs.coreAddress || "").trim();
     if (!coreAddress) throw new Error("coreAddress is required");
     const operation = String(inputs.operation || "").trim();
@@ -861,6 +988,7 @@ registerAction({
   type: "qi/governance.settings-proposal",
   can: "governance/settings-proposal",
   sideEffect: true,
+  proof: { fields: ["proposalId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
@@ -875,6 +1003,9 @@ registerAction({
     if (!handlers) {
       throw new Error("Handlers not available");
     }
+    if (!handlers.getPreProposalContractAddress || !handlers.getGroupContractAddress || !handlers.getProposalContractAddress || !handlers.createProposal) {
+      throw new Error("Governance proposal handlers not available");
+    }
     const coreAddress = String(inputs.coreAddress || "").trim();
     if (!coreAddress) throw new Error("coreAddress is required");
     const votingPeriodHours = Number(inputs.votingPeriodHours);
@@ -937,6 +1068,7 @@ registerAction({
   type: "qi/governance.transaction.send-funds",
   can: "governance.transaction/send-funds",
   sideEffect: true,
+  proof: { fields: ["proposalId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
@@ -952,6 +1084,9 @@ registerAction({
     if (!handlers) {
       throw new Error("Handlers not available");
     }
+    if (!handlers.getPreProposalContractAddress || !handlers.getGroupContractAddress || !handlers.getProposalContractAddress || !handlers.createProposal) {
+      throw new Error("Governance proposal handlers not available");
+    }
     const coreAddress = String(inputs.coreAddress || "").trim();
     if (!coreAddress) throw new Error("coreAddress is required");
     const recipient = String(inputs.recipient || "").trim();
@@ -995,6 +1130,7 @@ registerAction({
   type: "qi/http.request",
   can: "http/request",
   sideEffect: false,
+  proof: { fields: ["status"] },
   defaultRequiresConfirmation: false,
   // HTTP request can be triggered as a listener — a human assignee is DM'd
   // to invoke it when the upstream event fires. See §3.6 of the
@@ -1055,6 +1191,7 @@ registerAction({
   type: "qi/email.send",
   can: "email/send",
   sideEffect: true,
+  proof: { fields: ["messageId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "email/send",
   // Email send is autonomous-enough to be triggered by another block's event.
@@ -1120,6 +1257,7 @@ registerAction({
   type: "qi/human.checkbox.set",
   can: "human/checkbox",
   sideEffect: true,
+  proof: "none",
   defaultRequiresConfirmation: false,
   requiredCapability: "flow/execute",
   inputSchema: {
@@ -1161,6 +1299,7 @@ function registerFormSubmitAction(type, can) {
     type,
     can,
     sideEffect: true,
+    proof: "none",
     defaultRequiresConfirmation: false,
     requiredCapability: "flow/execute",
     // Additive: makes the form an event SOURCE so downstream blocks can
@@ -1210,6 +1349,7 @@ registerAction({
   type: "qi/notification.push",
   can: "notification/push",
   sideEffect: true,
+  proof: { fields: ["messageId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "notify/send",
   inputSchema: {
@@ -1266,6 +1406,7 @@ registerAction({
   type: "qi/bid.submit",
   can: "bid/submit",
   sideEffect: true,
+  proof: { fields: ["bidId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   inputSchema: {
@@ -1349,6 +1490,7 @@ registerAction({
   type: "qi/bid.evaluate",
   can: "bid/evaluate",
   sideEffect: true,
+  proof: { fields: ["bidId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
@@ -1495,7 +1637,7 @@ function extractSurveyAnswerSchema(survey) {
   if (!survey || typeof survey !== "object") return [];
   const json = survey;
   const collected = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const walk = (elements) => {
     if (!Array.isArray(elements)) return;
     for (const el of elements) {
@@ -1506,8 +1648,8 @@ function extractSurveyAnswerSchema(survey) {
       }
       const name = typeof el.name === "string" ? el.name.trim() : "";
       if (!name) continue;
-      if (seen.has(name)) continue;
-      seen.add(name);
+      if (seen2.has(name)) continue;
+      seen2.add(name);
       const rawType = typeof el.type === "string" ? el.type : "";
       const mapped = TYPE_MAP[rawType] ?? "string";
       let itemSchema;
@@ -1577,6 +1719,13 @@ registerAction({
   type: "qi/claim.submit",
   can: "claim/submit",
   sideEffect: true,
+  // Dynamic resolvers predate merge-by-default and intentionally control
+  // the full vocabulary (e.g. returning [] to hide the static baseline).
+  dynamicResolutionMode: "replace",
+  proof: { fields: ["claimId"] },
+  // Repeatable: a collection accepts many claims over the flow's life (e.g. a
+  // monthly submission). Never latches to a terminal Done. See cardinality.
+  cardinality: "many",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -1947,7 +2096,7 @@ function serializeXeroPaymentCreateInputs(inputs) {
   return JSON.stringify(inputs);
 }
 
-// src/mantine/utils/referenceResolver.ts
+// src/core/lib/flowEngine/referenceResolver.ts
 var REFERENCE_REGEX = /\{\{([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_.:]+)\}\}/g;
 function parseReferences(input) {
   const references = [];
@@ -1969,68 +2118,78 @@ function getNestedValue(obj, path) {
     return current?.[key];
   }, obj);
 }
-function resolveSingleReference(blockId, propPath, editorDocument, yRuntime, scope) {
+function resolveSingleReferenceDetailed(blockId, propPath, editorDocument, yRuntime, scope) {
   if (scope && Object.prototype.hasOwnProperty.call(scope, blockId)) {
     const root = scope[blockId];
-    if (root == null) return void 0;
-    return getNestedValue(root, propPath);
+    if (root == null) return { value: void 0, reason: "missing-value" };
+    const value2 = getNestedValue(root, propPath);
+    return { value: value2, reason: value2 === void 0 ? "missing-value" : void 0 };
   }
   if (!editorDocument || !Array.isArray(editorDocument)) {
-    return void 0;
+    return { value: void 0, reason: "unknown-block" };
   }
   const block = editorDocument.find((b) => b.id === blockId);
   if (!block) {
-    return void 0;
+    return { value: void 0, reason: "unknown-block" };
   }
   if (propPath.startsWith("output.")) {
-    if (!yRuntime) return void 0;
+    if (!yRuntime) return { value: void 0, reason: "missing-value" };
     const runtimeState = yRuntime.get(blockId);
-    if (!runtimeState?.output) return void 0;
+    if (!runtimeState?.output) return { value: void 0, reason: "missing-value" };
     const innerPath = propPath.substring("output.".length);
     const direct = getNestedValue(runtimeState.output, innerPath);
-    if (direct !== void 0) return direct;
+    if (direct !== void 0) return { value: direct };
     if (runtimeState.output.data !== void 0) {
-      return getNestedValue(runtimeState.output.data, innerPath);
+      const value2 = getNestedValue(runtimeState.output.data, innerPath);
+      return { value: value2, reason: value2 === void 0 ? "missing-value" : void 0 };
     }
     if (runtimeState.output.http?.data !== void 0) {
-      return getNestedValue(runtimeState.output.http.data, innerPath);
+      const value2 = getNestedValue(runtimeState.output.http.data, innerPath);
+      return { value: value2, reason: value2 === void 0 ? "missing-value" : void 0 };
     }
-    return void 0;
+    return { value: void 0, reason: "missing-value" };
   }
   if (propPath.startsWith("response.")) {
     const responseData = block.props.response;
     if (!responseData) {
-      return void 0;
+      return { value: void 0, reason: "missing-value" };
     }
     try {
       const parsedResponse = typeof responseData === "string" ? JSON.parse(responseData) : responseData;
       const innerPath = propPath.substring("response.".length);
       const value2 = getNestedValue(parsedResponse, innerPath);
-      return value2;
-    } catch (error) {
-      return void 0;
+      return { value: value2, reason: value2 === void 0 ? "missing-value" : void 0 };
+    } catch {
+      warnOnce(`ref-response-parse:${blockId}`, `[flow-config] block ${blockId}: props.response is not valid JSON; {{${blockId}.${propPath}}} cannot resolve`);
+      return { value: void 0, reason: "response-parse-error" };
     }
   }
   const value = getNestedValue(block.props, propPath);
-  return value;
+  return { value, reason: value === void 0 ? "missing-value" : void 0 };
 }
-function resolveReferences(input, editorDocument, options = {}) {
-  const { fallback = "", stringifyObjects = true, yRuntime, scope } = options;
+function resolveSingleReference(blockId, propPath, editorDocument, yRuntime, scope) {
+  return resolveSingleReferenceDetailed(blockId, propPath, editorDocument, yRuntime, scope).value;
+}
+function resolveReferencesDetailed(input, editorDocument, options = {}) {
+  const { fallback = "", stringifyObjects = true, yRuntime, scope, warnContext } = options;
+  const unresolved = [];
   if (input == null) {
-    return "";
+    return { value: "", unresolved };
   }
   const inputStr = String(input);
   const references = parseReferences(inputStr);
   if (references.length === 0) {
-    return inputStr;
+    return { value: inputStr, unresolved };
   }
   let result = inputStr;
   for (let i = references.length - 1; i >= 0; i--) {
     const ref = references[i];
-    const resolvedValue = resolveSingleReference(ref.blockId, ref.propPath, editorDocument, yRuntime, scope);
+    const resolution = resolveSingleReferenceDetailed(ref.blockId, ref.propPath, editorDocument, yRuntime, scope);
+    const resolvedValue = resolution.value;
     let replacementStr;
     if (resolvedValue === void 0 || resolvedValue === null) {
       replacementStr = fallback;
+      unresolved.push({ ref: ref.fullMatch, blockId: ref.blockId, propPath: ref.propPath, reason: resolution.reason || "missing-value" });
     } else if (typeof resolvedValue === "object") {
       replacementStr = stringifyObjects ? JSON.stringify(resolvedValue) : fallback;
     } else {
@@ -2038,7 +2197,15 @@ function resolveReferences(input, editorDocument, options = {}) {
     }
     result = result.substring(0, ref.startIndex) + replacementStr + result.substring(ref.endIndex);
   }
-  return result;
+  if (warnContext && unresolved.length > 0) {
+    for (const entry of unresolved) {
+      warnOnce(`ref-unresolved:${warnContext}:${entry.ref}`, `[flow-config] ${warnContext}: reference ${entry.ref} did not resolve (${entry.reason}); using fallback '${fallback}'`);
+    }
+  }
+  return { value: result, unresolved };
+}
+function resolveReferences(input, editorDocument, options = {}) {
+  return resolveReferencesDetailed(input, editorDocument, options).value;
 }
 function hasReferences(input) {
   if (input == null) return false;
@@ -2241,6 +2408,13 @@ registerAction({
   type: "qi/claim.evaluate",
   can: "claim/evaluate",
   sideEffect: true,
+  // Dynamic resolvers predate merge-by-default and intentionally control
+  // the full vocabulary (e.g. returning [] to hide the static baseline).
+  dynamicResolutionMode: "replace",
+  proof: { fields: ["claimId"] },
+  // Repeatable: an evaluator processes many claims over the flow's life. Never
+  // latches to a terminal Done. See cardinality.
+  cardinality: "many",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   // Static fallback — used until a collection is picked and the survey
@@ -2534,6 +2708,7 @@ registerAction({
   type: "qi/proposal.create",
   can: "proposal/create",
   sideEffect: true,
+  proof: { fields: ["proposalId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   inputSchema: {
@@ -2558,6 +2733,9 @@ registerAction({
     if (!handlers) {
       throw new Error("Handlers not available");
     }
+    if (!handlers.getPreProposalContractAddress || !handlers.getGroupContractAddress || !handlers.getProposalContractAddress || !handlers.createProposal) {
+      throw new Error("Governance proposal handlers not available");
+    }
     const coreAddress = String(inputs.coreAddress || "").trim();
     const title = String(inputs.title || "").trim();
     const description = String(inputs.description || "").trim();
@@ -2611,6 +2789,7 @@ registerAction({
   type: "qi/proposal.vote",
   can: "proposal/vote",
   sideEffect: true,
+  proof: { fields: ["votedAt"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   inputSchema: {
@@ -2634,6 +2813,9 @@ registerAction({
     if (!handlers) {
       throw new Error("Handlers not available");
     }
+    if (!handlers.vote) {
+      throw new Error("vote handler not available");
+    }
     const proposalId = Number(inputs.proposalId);
     const vote = String(inputs.vote || "").trim();
     const rationale = String(inputs.rationale || "").trim();
@@ -2667,6 +2849,7 @@ registerAction({
   type: "qi/protocol.select",
   can: "protocol/select",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -3946,6 +4129,7 @@ registerAction({
   type: "qi/domain.sign",
   can: "domain/sign",
   sideEffect: true,
+  proof: { fields: ["entityDid"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -4096,6 +4280,7 @@ registerAction({
     if (typeof handlers.createDomain !== "function") throw new Error("createDomain handler not implemented");
     if (typeof handlers.createAddLinkedResourceMessage !== "function") throw new Error("createAddLinkedResourceMessage handler not implemented");
     if (typeof handlers.executeTransaction !== "function") throw new Error("executeTransaction handler not implemented");
+    const { requestPin, signCredential, publicFileUpload } = handlers;
     const saveCheckpoint = (updates) => {
       checkpoint = {
         ...checkpoint,
@@ -4160,14 +4345,14 @@ registerAction({
         });
         let signedCredential;
         for (let attempt = 1; attempt <= MAX_PIN_ATTEMPTS; attempt++) {
-          const pin = await handlers.requestPin({
+          const pin = await requestPin({
             title: "Sign Domain Card",
             description: attempt === 1 ? "Enter your PIN to sign the Domain Card credential" : "Incorrect PIN. Re-enter your PIN to sign the Domain Card credential.",
             submitText: "Sign"
           });
           if (!pin) throw new Error("PIN entry cancelled");
           try {
-            ({ signedCredential } = await handlers.signCredential({
+            ({ signedCredential } = await signCredential({
               issuerDid,
               issuerType: "user",
               credential: unsignedCredential,
@@ -4186,7 +4371,7 @@ registerAction({
         const credentialFile = new File([credentialBlob], "domainCard.json", {
           type: "application/json"
         });
-        const uploadResult = await handlers.publicFileUpload(credentialFile);
+        const uploadResult = await publicFileUpload(credentialFile);
         return {
           ...buildDomainCardLinkedResource({
             entityDid,
@@ -4360,6 +4545,7 @@ registerAction({
   type: "qi/domain.card-preview",
   can: "domain/card-preview",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4439,6 +4625,7 @@ registerAction({
   type: "oracle",
   can: "oracle/query",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4466,6 +4653,7 @@ registerAction({
   type: "qi/credential.store",
   can: "credential/store",
   sideEffect: true,
+  proof: { fields: ["storedAt"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/execute",
   inputSchema: {
@@ -4527,6 +4715,7 @@ registerAction({
   type: "qi/payment.execute",
   can: "payment/execute",
   sideEffect: true,
+  proof: { fields: ["paymentBlockId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   inputSchema: {
@@ -4611,6 +4800,7 @@ registerAction({
   type: "qi/matrix.dm",
   can: "matrix/dm",
   sideEffect: true,
+  proof: { fields: ["roomId"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4648,6 +4838,7 @@ registerAction({
   type: "qi/wallet.generate",
   can: "wallet/generate",
   sideEffect: false,
+  proof: { fields: ["address"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4674,6 +4865,7 @@ registerAction({
   type: "qi/wallet.fund",
   can: "wallet/fund",
   sideEffect: true,
+  proof: { fields: ["transactionHash"] },
   defaultRequiresConfirmation: true,
   inputSchema: {
     type: "object",
@@ -4702,6 +4894,7 @@ registerAction({
   type: "qi/wallet.generateAndFund",
   can: "wallet/generateAndFund",
   sideEffect: true,
+  proof: { fields: ["transactionHash"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4752,6 +4945,7 @@ registerAction({
   type: "qi/iid.create",
   can: "iid/create",
   sideEffect: true,
+  proof: { fields: ["transactionHash", "alreadyExisted"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4790,6 +4984,7 @@ registerAction({
   type: "qi/matrix.register",
   can: "matrix/register",
   sideEffect: true,
+  proof: { fields: ["matrixUserId"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4839,6 +5034,8 @@ registerAction({
   type: "qi/identity.create",
   can: "identity/create",
   sideEffect: true,
+  // Dual-phase proof: on-chain IID (transactionHash or alreadyExisted) AND matrix registration.
+  proof: { validate: (output) => !!(output.transactionHash || output.alreadyExisted) && !!output.matrixUserId },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -4939,6 +5136,7 @@ registerAction({
   type: "qi/entity.createOracle",
   can: "entity/createOracle",
   sideEffect: true,
+  proof: { fields: ["entityDid"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5041,6 +5239,7 @@ registerAction({
   type: "qi/sandbox.provision",
   can: "sandbox/provision",
   sideEffect: true,
+  proof: { fields: ["status", "sandboxUrl"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5073,6 +5272,7 @@ registerAction({
   type: "qi/oracle.contract",
   can: "oracle/contract",
   sideEffect: true,
+  proof: { fields: ["userOracleRoomId"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5103,6 +5303,7 @@ registerAction({
   type: "qi/oracle.storeSecrets",
   can: "oracle/storeSecrets",
   sideEffect: true,
+  proof: { fields: ["storedSecrets"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5193,6 +5394,7 @@ registerAction({
   type: "qi/oracle.storeConfig",
   can: "oracle/storeConfig",
   sideEffect: true,
+  proof: { fields: ["configStored"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5263,6 +5465,7 @@ registerAction({
   type: "qi/oracle.storeSecretsAndConfig",
   can: "oracle/storeSecretsAndConfig",
   sideEffect: true,
+  proof: { fields: ["storedSecrets"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5414,6 +5617,7 @@ registerAction({
   type: "qi/oracle.configureOracle",
   can: "oracle/configureOracle",
   sideEffect: true,
+  proof: { fields: ["configStored"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5594,6 +5798,7 @@ registerAction({
   type: "qi/oracle.deploySetup",
   can: "oracle/deploySetup",
   sideEffect: true,
+  proof: { fields: ["setupComplete"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5628,6 +5833,7 @@ registerAction({
   type: "qi/oracle.deployStart",
   can: "oracle/deployStart",
   sideEffect: true,
+  proof: { fields: ["processId", "status"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5661,6 +5867,7 @@ registerAction({
   type: "qi/oracle.deploy",
   can: "oracle/deploy",
   sideEffect: true,
+  proof: { fields: ["processId", "status"] },
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -5796,6 +6003,10 @@ registerAction({
   type: COLLECTION_LIFECYCLE_ACTION_TYPE,
   can: "collection/lifecycle",
   sideEffect: true,
+  // Dynamic resolvers predate merge-by-default and intentionally control
+  // the full vocabulary (e.g. returning [] to hide the static baseline).
+  dynamicResolutionMode: "replace",
+  proof: { fields: ["collectionId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: COLLECTION_LIFECYCLE_OUTPUT_SCHEMA,
@@ -5992,6 +6203,13 @@ registerAction({
   type: COLLECTION_USERS_ACTION_TYPE,
   can: "collection/users",
   sideEffect: true,
+  // Dynamic resolvers predate merge-by-default and intentionally control
+  // the full vocabulary (e.g. returning [] to hide the static baseline).
+  dynamicResolutionMode: "replace",
+  proof: { fields: ["transactionHash", "collectionId"] },
+  // Repeatable: members are granted/revoked many times over the flow's life.
+  // Never latches to a terminal Done. See cardinality.
+  cardinality: "many",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: COLLECTION_USERS_OUTPUT_SCHEMA,
@@ -6155,6 +6373,7 @@ registerAction({
   type: "qi/carbon.loadBatches",
   can: "carbon/load",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
@@ -6181,6 +6400,7 @@ registerAction({
   type: "qi/carbon.harvest",
   can: "carbon/harvest",
   sideEffect: true,
+  proof: { fields: ["transactionHash"] },
   defaultRequiresConfirmation: true,
   inputSchema: {
     type: "object",
@@ -6220,6 +6440,7 @@ registerAction({
   type: "qi/carbon.retire",
   can: "carbon/retire",
   sideEffect: true,
+  proof: { fields: ["transactionHash"] },
   defaultRequiresConfirmation: true,
   inputSchema: {
     type: "object",
@@ -6281,6 +6502,7 @@ registerAction({
   type: "qi/entity.transfer",
   can: "entity/transfer",
   sideEffect: true,
+  proof: { fields: ["transactionHash"] },
   defaultRequiresConfirmation: true,
   outputSchema: ENTITY_TRANSFER_OUTPUT,
   inputSchema: {
@@ -6426,6 +6648,8 @@ registerAction({
   type: "qi/gmail.email.send",
   can: "gmail.email/send",
   sideEffect: true,
+  // Proof of execution: Gmail returns the sent message id. Matches qi/email.send.
+  proof: { fields: ["messageId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → send email).
@@ -6498,6 +6722,11 @@ registerAction({
   type: "qi/outlook.email.send",
   can: "outlook.email/send",
   sideEffect: true,
+  // Outlook's send tool often returns no message id (see run() below), so there
+  // is no reliable output field to prove execution — a successful tool call
+  // (run() throws on failure) is the signal. Declared 'none' rather than
+  // requiring messageId, which would push every id-less send to needs_verification.
+  proof: "none",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → send email).
@@ -6570,6 +6799,8 @@ registerAction({
   type: "qi/slack.message.send",
   can: "slack.message/send",
   sideEffect: true,
+  // Proof of execution: Slack returns the posted message timestamp (ts).
+  proof: { fields: ["messageTs"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → post message).
@@ -6645,6 +6876,8 @@ registerAction({
   type: "qi/googlecalendar.event.create",
   can: "googlecalendar.event/create",
   sideEffect: true,
+  // Proof of execution: the created event's id. Matches qi/calendar.event.create.
+  proof: { fields: ["eventId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -6741,6 +6974,7 @@ registerAction({
   type: "qi/calendar.event.create",
   can: "calendar.event/create",
   sideEffect: true,
+  proof: { fields: ["eventId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -6848,6 +7082,7 @@ registerAction({
   type: "qi/calendar.event.update",
   can: "calendar.event/update",
   sideEffect: true,
+  proof: { fields: ["eventId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -6957,6 +7192,7 @@ registerAction({
   type: "qi/calendar.event.list",
   can: "calendar.event/list",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: false,
@@ -7038,6 +7274,7 @@ registerAction({
   type: "qi/xero.contact.create",
   can: "xero.contact/create",
   sideEffect: true,
+  proof: { fields: ["contactId"] },
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -7136,6 +7373,10 @@ registerAction({
   type: "qi/xero.invoice.create",
   can: "xero.invoice/create",
   sideEffect: true,
+  proof: { fields: ["invoiceId"] },
+  // Repeatable: many invoices are created over the flow's life. Never latches
+  // to a terminal Done. See cardinality.
+  cardinality: "many",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -7241,6 +7482,7 @@ registerAction({
   type: "qi/xero.invoice.list",
   can: "xero.invoice/list",
   sideEffect: false,
+  proof: "none",
   defaultRequiresConfirmation: false,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: false,
@@ -7321,6 +7563,10 @@ registerAction({
   type: "qi/xero.payment.create",
   can: "xero.payment/create",
   sideEffect: true,
+  proof: { fields: ["paymentId"] },
+  // Repeatable: many payments are created over the flow's life. Never latches
+  // to a terminal Done. See cardinality.
+  cardinality: "many",
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
@@ -9031,175 +9277,285 @@ var createUcanService = (config) => {
   };
 };
 
-// src/core/lib/flowEngine/utils.ts
-var buildAuthzFromProps = (props) => {
-  const linkedClaimCollectionId = typeof props.linkedClaimCollectionId === "string" ? props.linkedClaimCollectionId.trim() : "";
-  const authz = {};
-  if (linkedClaimCollectionId) {
-    authz.linkedClaim = { collectionId: linkedClaimCollectionId };
-  }
-  return authz;
-};
-var buildFlowNodeFromBlock = (block) => {
-  const base = {
-    id: block.id,
-    type: block.type,
-    props: block.props || {}
-  };
-  const authz = buildAuthzFromProps(block.props || {});
-  return {
-    ...base,
-    ...authz
-  };
-};
-
-// src/core/lib/flowEngine/runtime.ts
-var XERO_WORK_ITEMS_MAP_NAME = "xeroWorkItems";
-var XERO_CONNECTION_MAP_NAME = "xeroConnection";
-var ensureStateObject = (value) => {
-  if (!value || typeof value !== "object") {
-    return {};
-  }
-  return { ...value };
-};
-var createYMapManager = (map) => {
-  return {
-    get: (nodeId) => {
-      const stored = map.get(nodeId);
-      return ensureStateObject(stored);
-    },
-    update: (nodeId, updates) => {
-      const current = ensureStateObject(map.get(nodeId));
-      map.set(nodeId, { ...current, ...updates });
-    }
-  };
-};
-var createMemoryManager = () => {
-  const memory = /* @__PURE__ */ new Map();
-  return {
-    get: (nodeId) => ensureStateObject(memory.get(nodeId)),
-    update: (nodeId, updates) => {
-      const current = ensureStateObject(memory.get(nodeId));
-      memory.set(nodeId, { ...current, ...updates });
-    }
-  };
-};
-var createRuntimeStateManager = (editor) => {
-  if (editor?._yRuntime) {
-    return createYMapManager(editor._yRuntime);
-  }
-  return createMemoryManager();
-};
-var createYDocRuntimeManager = (yDoc) => {
-  return createYMapManager(yDoc.getMap("runtime"));
-};
-function clearRuntimeForTemplateClone(yDoc) {
-  const runtime = yDoc.getMap("runtime");
-  const invocations = yDoc.getMap("invocations");
-  const pendingInvocations = yDoc.getMap("pendingInvocations");
-  const agentOutbox = yDoc.getMap("agentOutbox");
-  const agentLeases = yDoc.getMap("agentLeases");
-  const auditTrail = yDoc.getMap("auditTrail");
-  const xeroWorkItems = yDoc.getMap(XERO_WORK_ITEMS_MAP_NAME);
-  const xeroConnection = yDoc.getMap(XERO_CONNECTION_MAP_NAME);
-  yDoc.transact(() => {
-    runtime.forEach((_, key) => runtime.delete(key));
-    invocations.forEach((_, key) => invocations.delete(key));
-    pendingInvocations.forEach((_, key) => pendingInvocations.delete(key));
-    agentOutbox.forEach((_, key) => agentOutbox.delete(key));
-    agentLeases.forEach((_, key) => agentLeases.delete(key));
-    auditTrail.forEach((_, key) => auditTrail.delete(key));
-    xeroWorkItems.forEach((_, key) => xeroWorkItems.delete(key));
-    xeroConnection.forEach((_, key) => xeroConnection.delete(key));
-  });
-}
-
 // src/core/types/baseUcan.ts
 function isRuntimeRef(value) {
   return typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string";
 }
 
-// src/core/lib/flowCompiler/resolveRefs.ts
-function resolveRuntimeRefs(nb, getNodeOutput2, triggerContext) {
-  return resolveValue(nb, getNodeOutput2, triggerContext);
+// src/core/lib/flowEngine/triggers.ts
+import * as Y from "yjs";
+var RUN_RECORD_AUDIT_TYPE = "block.run";
+function computePendingInvocationId(args) {
+  const { sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex } = args;
+  const input = `${sourceBlockId}:${sourceRunId}:${listenerBlockId}:${eventName}:${eventIndex}`;
+  return `pi-${fnv1a32(input)}`;
 }
-function resolveValue(value, getNodeOutput2, triggerContext) {
+function snapshotInputRefs(inputs, getNodeOutput2) {
+  const snapshots = {};
+  walkRefs(inputs, (ref) => {
+    if (ref.$ref.startsWith("trigger.")) return;
+    const parsed = parseOutputRef(ref.$ref);
+    if (!parsed) return;
+    const output = getNodeOutput2(parsed.nodeId);
+    if (!output) return;
+    snapshots[ref.$ref] = getNestedValue(output, parsed.fieldPath);
+  });
+  return snapshots;
+}
+function walkRefs(value, visit) {
   if (isRuntimeRef(value)) {
-    return resolveRef(value.$ref, getNodeOutput2, triggerContext);
+    visit(value);
+    return;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => resolveValue(item, getNodeOutput2, triggerContext));
+    for (const item of value) walkRefs(item, visit);
+    return;
   }
   if (typeof value === "object" && value !== null) {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = resolveValue(val, getNodeOutput2, triggerContext);
-    }
-    return result;
+    for (const v of Object.values(value)) walkRefs(v, visit);
   }
-  return value;
 }
-function resolveRef(ref, getNodeOutput2, triggerContext) {
-  if (ref.startsWith("trigger.payload.")) {
-    if (!triggerContext) {
-      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
-    }
-    const fieldPath2 = ref.slice("trigger.payload.".length);
-    return getNestedValue2(triggerContext.payload, fieldPath2);
-  }
-  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
-    return triggerContext.refSnapshots[ref];
-  }
+function parseOutputRef(ref) {
   const outputIndex = ref.indexOf(".output.");
-  if (outputIndex === -1) {
-    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
+  if (outputIndex === -1) return null;
+  return {
+    nodeId: ref.slice(0, outputIndex),
+    fieldPath: ref.slice(outputIndex + ".output.".length)
+  };
+}
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
   }
-  const nodeId = ref.slice(0, outputIndex);
-  const fieldPath = ref.slice(outputIndex + ".output.".length);
-  const output = getNodeOutput2(nodeId);
-  if (!output) {
-    return void 0;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var PENDING_INVOCATIONS_MAP_KEY = "pendingInvocations";
+function getPendingInvocationsMap(yDoc) {
+  return yDoc.getMap(PENDING_INVOCATIONS_MAP_KEY);
+}
+function getOrCreateBlockPendingMap(yDoc, blockId) {
+  const outer = getPendingInvocationsMap(yDoc);
+  let inner = outer.get(blockId);
+  if (!inner) {
+    inner = new Y.Map();
+    outer.set(blockId, inner);
   }
-  return getNestedValue2(output, fieldPath);
+  return inner;
 }
-function getNestedValue2(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") {
-      return void 0;
+function readPendingInvocations(yDoc, blockId) {
+  const outer = getPendingInvocationsMap(yDoc);
+  const inner = outer.get(blockId);
+  if (!inner) return [];
+  const items = [];
+  inner.forEach((value) => {
+    if (value && typeof value === "object") {
+      items.push(value);
     }
-    current = current[part];
+  });
+  items.sort((a, b) => a.emittedAt.localeCompare(b.emittedAt));
+  return items;
+}
+function queuePendingInvocation(yDoc, listenerBlockId, invocation) {
+  let created = false;
+  yDoc.transact(() => {
+    const inner = getOrCreateBlockPendingMap(yDoc, listenerBlockId);
+    if (inner.has(invocation.id)) return;
+    inner.set(invocation.id, invocation);
+    created = true;
+  });
+  return created;
+}
+function removePendingInvocation(yDoc, listenerBlockId, pendingInvocationId) {
+  const outer = getPendingInvocationsMap(yDoc);
+  const inner = outer.get(listenerBlockId);
+  if (!inner) return false;
+  if (!inner.has(pendingInvocationId)) return false;
+  inner.delete(pendingInvocationId);
+  return true;
+}
+function readConsumedPendingInvocationIds(yDoc, listenerBlockId) {
+  const consumed = /* @__PURE__ */ new Set();
+  for (const record of readRunRecords(yDoc, listenerBlockId)) {
+    if (record.fromPendingInvocationId) consumed.add(record.fromPendingInvocationId);
   }
-  return current;
+  return consumed;
 }
-
-// src/core/lib/flowEngine/versionManifest.ts
-var VERSION_MANIFEST = {
-  "0.3": {
-    version: "0.3",
-    label: "Legacy",
-    ucanRequired: false,
-    delegationRootRequired: false,
-    whitelistOnlyAllowed: true,
-    unrestrictedAllowed: true,
-    executionPath: "legacy",
-    authorizationFn: "v1",
-    allowedAuthModes: ["anyone", "actors", "capability"],
-    ui: {
-      showDelegationPanel: false,
-      showWhitelistConfig: true,
-      showAnyoneConfig: true,
-      showMigrationBanner: true,
-      requirePinForExecution: false
-    },
+function sweepExpiredPendingInvocations(yDoc, now = Date.now()) {
+  const outer = getPendingInvocationsMap(yDoc);
+  let removed = 0;
+  outer.forEach((inner, listenerBlockId) => {
+    const innerMap = inner;
+    if (!innerMap || typeof innerMap.forEach !== "function") return;
+    const expiredIds = [];
+    innerMap.forEach((value, id) => {
+      const expiresAt = value?.expiresAt;
+      if (expiresAt && Date.parse(expiresAt) < now) expiredIds.push(id);
+    });
+    for (const id of expiredIds) {
+      innerMap.delete(id);
+      removed += 1;
+    }
+    void listenerBlockId;
+  });
+  return removed;
+}
+var BARRIER_STATE_MAP_KEY = "barrierState";
+function getBarrierStateMap(yDoc) {
+  return yDoc.getMap(BARRIER_STATE_MAP_KEY);
+}
+function getOrCreateListenerBarrierMap(yDoc, listenerBlockId) {
+  const outer = getBarrierStateMap(yDoc);
+  let inner = outer.get(listenerBlockId);
+  if (!inner) {
+    inner = new Y.Map();
+    outer.set(listenerBlockId, inner);
+  }
+  return inner;
+}
+function recordBarrierEvent(yDoc, listenerBlockId, entry) {
+  let written = false;
+  yDoc.transact(() => {
+    const inner = getOrCreateListenerBarrierMap(yDoc, listenerBlockId);
+    const key = `${entry.sourceBlockId}::${entry.eventName}`;
+    const existing = inner.get(key);
+    if (existing && typeof existing === "object" && existing.runId === entry.runId) return;
+    inner.set(key, entry);
+    written = true;
+  });
+  return written;
+}
+function readBarrierState(yDoc, listenerBlockId) {
+  const outer = getBarrierStateMap(yDoc);
+  const inner = outer.get(listenerBlockId);
+  if (!inner) return [];
+  const entries = [];
+  inner.forEach((value) => {
+    if (value && typeof value === "object") {
+      entries.push(value);
+    }
+  });
+  return entries;
+}
+function clearBarrierState(yDoc, listenerBlockId) {
+  const outer = getBarrierStateMap(yDoc);
+  yDoc.transact(() => {
+    outer.delete(listenerBlockId);
+  });
+}
+function computeBarrierInvocationId(entries, listenerBlockId) {
+  const sorted = [...entries].sort((a, b) => a.sourceBlockId.localeCompare(b.sourceBlockId));
+  const input = sorted.map((e) => `${e.sourceBlockId}:${e.runId}:${e.eventName}`).join("|") + `|>${listenerBlockId}`;
+  return `bi-${fnv1a32(input)}`;
+}
+function mergeBarrierPayloads(entries) {
+  const merged = {};
+  for (const entry of entries) {
+    if (entry.alias) {
+      merged[entry.alias] = entry.payload;
+    } else {
+      Object.assign(merged, entry.payload);
+    }
+  }
+  return merged;
+}
+function appendRunRecord(yDoc, blockId, details, userId) {
+  const auditMap = yDoc.getMap("auditTrail");
+  yDoc.transact(() => {
+    let arr = auditMap.get(blockId);
+    if (!arr) {
+      arr = new Y.Array();
+      auditMap.set(blockId, arr);
+    }
+    const event = {
+      id: `${details.runId}`,
+      blockId,
+      type: RUN_RECORD_AUDIT_TYPE,
+      details,
+      message: void 0,
+      meta: {
+        timestamp: details.completedAt,
+        userId,
+        editable: false
+      }
+    };
+    arr.push([event]);
+  });
+}
+function readRunRecords(yDoc, blockId) {
+  const auditMap = yDoc.getMap("auditTrail");
+  const arr = auditMap.get(blockId);
+  if (!arr) return [];
+  const records = [];
+  arr.forEach((entry) => {
+    if (!entry || typeof entry !== "object") return;
+    const e = entry;
+    if (e.type === RUN_RECORD_AUDIT_TYPE && e.details) {
+      records.push(e.details);
+    }
+  });
+  return records;
+}
+function findFailedListenersForSourceRun(yDoc, sourceBlockId, sourceRunId, listenerBlockIds) {
+  const failures = [];
+  for (const listenerBlockId of listenerBlockIds) {
+    const records = readRunRecords(yDoc, listenerBlockId);
+    for (const record of records) {
+      if (!record.error) continue;
+      if (record.triggeredBy?.sourceBlockId !== sourceBlockId) continue;
+      if (record.fromPendingInvocationId == null) continue;
+      const sourceRunIdField = record.sourceRunId;
+      if (sourceRunIdField && sourceRunIdField !== sourceRunId) continue;
+      failures.push({ listenerBlockId, record });
+    }
+  }
+  return failures;
+}
+function replayFailedListenerRun(yDoc, failedRecord, listenerBlockId, originalPayload, originalRefSnapshots, assigneeDid) {
+  if (!failedRecord.triggeredBy) return false;
+  const replayId = `${failedRecord.runId}:replay-${Date.now().toString(36)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const replay = {
+    id: replayId,
+    triggeringBlockId: failedRecord.triggeredBy.sourceBlockId,
+    sourceRunId: failedRecord.sourceRunId || failedRecord.runId,
+    eventName: failedRecord.triggeredBy.eventName,
+    eventIndex: 0,
+    payload: originalPayload,
+    refSnapshots: originalRefSnapshots,
+    assigneeDid,
+    emittedAt: now,
+    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+  };
+  return queuePendingInvocation(yDoc, listenerBlockId, replay);
+}
+
+// src/core/lib/flowEngine/versionManifest.ts
+var VERSION_MANIFEST = {
+  "0.3": {
+    version: "0.3",
+    label: "Legacy",
+    ucanRequired: false,
+    delegationRootRequired: false,
+    whitelistOnlyAllowed: true,
+    unrestrictedAllowed: true,
+    executionPath: "legacy",
+    authorizationFn: "v1",
+    allowedAuthModes: ["anyone", "actors", "capability"],
+    ui: {
+      showDelegationPanel: false,
+      showWhitelistConfig: true,
+      showAnyoneConfig: true,
+      showMigrationBanner: true,
+      requirePinForExecution: false
+    },
     description: "Legacy version. UCAN optional, whitelist-only authorization accepted."
   },
   "1.0.0": {
     version: "1.0.0",
     label: "UCAN Required",
-    /** TEMP Disablement - needs to be true TODO */
-    ucanRequired: false,
+    ucanRequired: true,
     delegationRootRequired: true,
     whitelistOnlyAllowed: false,
     unrestrictedAllowed: false,
@@ -9217,6 +9573,7 @@ var VERSION_MANIFEST = {
   }
 };
 var LATEST_VERSION = "1.0.0";
+var MIGRATION_PATH = ["0.3", "1.0.0"];
 function getVersionPolicy(version) {
   const policy = VERSION_MANIFEST[version];
   if (!policy) {
@@ -9224,635 +9581,673 @@ function getVersionPolicy(version) {
   }
   return policy;
 }
+function isVersionAtLeast(current, minimum) {
+  const currentIdx = MIGRATION_PATH.indexOf(current);
+  const minimumIdx = MIGRATION_PATH.indexOf(minimum);
+  const effectiveCurrent = currentIdx === -1 ? MIGRATION_PATH.length : currentIdx;
+  return effectiveCurrent >= minimumIdx;
+}
 
-// src/core/lib/flowEngine/authorization.ts
-var isAuthorized = async (blockId, actorDid, ucanService, flowUri, schemaVersion) => {
-  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
-  if (policy && !policy.ucanRequired) {
-    return { authorized: true };
+// src/core/lib/flowEngine/reconcile.ts
+var _reconcileRunning = false;
+function reconcilePendingInvocations(editor) {
+  if (_reconcileRunning) return;
+  _reconcileRunning = true;
+  try {
+    _reconcilePendingInvocationsInner(editor);
+  } finally {
+    _reconcileRunning = false;
   }
-  if (!ucanService) {
-    if (!policy) {
-      return { authorized: true };
+}
+function _reconcilePendingInvocationsInner(editor) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return;
+  const blocks = editor.document || [];
+  if (blocks.length === 0) return;
+  const listenersBySource = /* @__PURE__ */ new Map();
+  const barrierListenersBySource = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const trigger = parseTrigger(block);
+    if (!trigger) continue;
+    if (trigger.type === "block.event") {
+      if (!trigger.sourceBlockId || !trigger.eventName) continue;
+      const key = `${trigger.sourceBlockId}::${trigger.eventName}`;
+      if (!listenersBySource.has(key)) listenersBySource.set(key, []);
+      listenersBySource.get(key).push({ block, trigger });
+    } else if (trigger.type === "block.event.all" && trigger.sources) {
+      for (const source of trigger.sources) {
+        if (!source.sourceBlockId || !source.eventName) continue;
+        const key = `${source.sourceBlockId}::${source.eventName}`;
+        if (!barrierListenersBySource.has(key)) barrierListenersBySource.set(key, []);
+        barrierListenersBySource.get(key).push({ block, trigger, source });
+      }
     }
-    return {
-      authorized: false,
-      reason: "UCAN service is not configured. This flow version requires UCAN authorization."
-    };
-  }
-  const capability = {
-    can: "flow/block/execute",
-    with: `${flowUri}:${blockId}`
-  };
-  const result = await ucanService.validateDelegationChain(actorDid, capability);
-  if (!result.valid) {
-    return {
-      authorized: false,
-      reason: result.error || "No valid capability chain found"
-    };
   }
-  const proofCids = result.proofChain?.map((d) => d.cid) || [];
-  return {
-    authorized: true,
-    capabilityId: proofCids[0],
-    proofCids
-  };
-};
-
-// src/core/lib/flowEngine/executor.ts
-var updateRuntimeAfterSuccess = (node, actorDid, runtime, actionResult, invocationCid, now) => {
-  const updates = {
-    submittedByDid: actionResult.submittedByDid || actorDid,
-    evaluationStatus: actionResult.evaluationStatus || "pending",
-    executionTimestamp: now ? now() : Date.now(),
-    lastInvocationCid: invocationCid
+  if (listenersBySource.size === 0 && barrierListenersBySource.size === 0) return;
+  const now = Date.now();
+  sweepExpiredPendingInvocations(yDoc, now);
+  const consumedByListener = /* @__PURE__ */ new Map();
+  const isConsumed = (listenerBlockId, pendingId) => {
+    let consumed = consumedByListener.get(listenerBlockId);
+    if (!consumed) {
+      consumed = readConsumedPendingInvocationIds(yDoc, listenerBlockId);
+      consumedByListener.set(listenerBlockId, consumed);
+    }
+    return consumed.has(pendingId);
+  };
+  const schemaVersionRaw = yDoc.getMap("root").get("schema_version");
+  const ucanRequired = typeof schemaVersionRaw === "string" ? !!getVersionPolicy(schemaVersionRaw)?.ucanRequired : false;
+  const invocationsMap = yDoc.getMap("invocations");
+  const runtimeMap = editor._yRuntime;
+  const getNodeOutput2 = (nodeId) => {
+    if (!runtimeMap) return void 0;
+    const state = runtimeMap.get(nodeId);
+    if (!state || typeof state !== "object") return void 0;
+    const out = state.output;
+    return out && typeof out === "object" ? out : void 0;
   };
-  if (actionResult.claimId) {
-    updates.claimId = actionResult.claimId;
+  for (const block of blocks) {
+    const sourceBlockId = block?.id;
+    if (!sourceBlockId) continue;
+    let hasAnyListener = false;
+    for (const key of listenersBySource.keys()) {
+      if (key.startsWith(`${sourceBlockId}::`)) {
+        hasAnyListener = true;
+        break;
+      }
+    }
+    for (const key of barrierListenersBySource.keys()) {
+      if (key.startsWith(`${sourceBlockId}::`)) {
+        hasAnyListener = true;
+        break;
+      }
+    }
+    if (!hasAnyListener) continue;
+    const records = readRunRecords(yDoc, sourceBlockId);
+    for (const record of records) {
+      if (!isTrustedRunRecord(record, ucanRequired, invocationsMap)) continue;
+      processRunRecord(yDoc, sourceBlockId, record, listenersBySource, getNodeOutput2, runtimeMap, isConsumed, now);
+      processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, runtimeMap, isConsumed, now);
+    }
   }
-  runtime.update(node.id, updates);
-};
-var executeNode = async ({ node, actorDid, actorType, entityRoomId, context, action, pin }) => {
-  const { runtime, ucanService, invocationStore, flowUri, flowId, schemaVersion, now } = context;
-  const auth = await isAuthorized(node.id, actorDid, ucanService, flowUri, schemaVersion);
-  if (!auth.authorized) {
-    return { success: false, stage: "authorization", error: auth.reason };
-  }
-  if (node.linkedClaim && !node.linkedClaim.collectionId) {
-    return { success: false, stage: "claim", error: "Linked claim collection is required but missing." };
-  }
-  let invocationCid;
-  let invocationData;
-  if (ucanService && auth.proofCids && auth.proofCids.length > 0) {
-    const capability = {
-      can: "flow/block/execute",
-      with: `${flowUri}:${node.id}`
-    };
-    try {
-      const invocationResult = await ucanService.createAndValidateInvocation(
-        {
-          invokerDid: actorDid,
-          invokerType: actorType,
-          entityRoomId,
-          capability,
-          proofs: auth.proofCids,
-          pin
-        },
-        flowId,
-        node.id
-      );
-      if (!invocationResult.valid) {
-        return {
-          success: false,
-          stage: "authorization",
-          error: `Invocation validation failed: ${invocationResult.error}`
-        };
-      }
-      invocationCid = invocationResult.cid;
-      invocationData = invocationResult.invocation;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to create invocation";
-      return { success: false, stage: "authorization", error: message };
-    }
-  }
-  try {
-    const result = await action();
-    if (node.linkedClaim && !result.claimId) {
-      if (invocationStore && invocationCid && invocationData) {
-        const storedInvocation = {
-          cid: invocationCid,
-          invocation: invocationData,
-          invokerDid: actorDid,
-          capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-          executedAt: now ? now() : Date.now(),
-          flowId,
-          blockId: node.id,
-          result: "failure",
-          error: "Execution did not return a claimId for linked claim requirement.",
-          proofCids: auth.proofCids || []
-        };
-        invocationStore.add(storedInvocation);
-      }
-      return {
-        success: false,
-        stage: "claim",
-        error: "Execution did not return a claimId for linked claim requirement.",
-        invocationCid
+}
+function isTrustedRunRecord(record, ucanRequired, invocationsMap) {
+  if (!ucanRequired) return true;
+  if (!record.invocationCid) return false;
+  return invocationsMap.get(record.invocationCid) !== void 0;
+}
+function processRunRecord(yDoc, sourceBlockId, record, listenersBySource, getNodeOutput2, runtimeMap, isConsumed, now) {
+  if (!Array.isArray(record.events)) return;
+  record.events.forEach((event, eventIndex) => {
+    if (!event?.name) return;
+    const key = `${sourceBlockId}::${event.name}`;
+    const listeners = listenersBySource.get(key);
+    if (!listeners || listeners.length === 0) return;
+    for (const { block: listenerBlock } of listeners) {
+      const listenerBlockId = listenerBlock.id;
+      if (!listenerBlockId) continue;
+      const id = computePendingInvocationId({
+        sourceBlockId,
+        sourceRunId: record.runId,
+        listenerBlockId,
+        eventName: event.name,
+        eventIndex
+      });
+      if (isConsumed(listenerBlockId, id)) continue;
+      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
+      const inputs = parseInputs(listenerBlock);
+      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
+      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
+      if (expiresAt && Date.parse(expiresAt) < now) continue;
+      const invocation = {
+        id,
+        triggeringBlockId: sourceBlockId,
+        sourceRunId: record.runId,
+        eventName: event.name,
+        eventIndex,
+        payload: event.payload,
+        refSnapshots,
+        assigneeDid,
+        emittedAt: record.completedAt,
+        expiresAt
       };
+      queuePendingInvocation(yDoc, listenerBlockId, invocation);
+      if (runtimeMap) {
+        const prev = runtimeMap.get(listenerBlockId) || {};
+        runtimeMap.set(listenerBlockId, {
+          ...prev,
+          pendingPayload: { ...event.payload, ...refSnapshots }
+        });
+      }
     }
-    if (invocationStore && invocationCid && invocationData) {
-      const storedInvocation = {
-        cid: invocationCid,
-        invocation: invocationData,
-        invokerDid: actorDid,
-        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-        executedAt: now ? now() : Date.now(),
-        flowId,
-        blockId: node.id,
-        result: "success",
-        proofCids: auth.proofCids || [],
-        claimId: result.claimId
+  });
+}
+function processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, runtimeMap, isConsumed, now) {
+  if (!Array.isArray(record.events)) return;
+  for (const event of record.events) {
+    if (!event?.name) continue;
+    const key = `${sourceBlockId}::${event.name}`;
+    const listeners = barrierListenersBySource.get(key);
+    if (!listeners || listeners.length === 0) continue;
+    for (const { block: listenerBlock, trigger, source } of listeners) {
+      const listenerBlockId = listenerBlock.id;
+      if (!listenerBlockId) continue;
+      const entry = {
+        sourceBlockId,
+        eventName: event.name,
+        alias: source.alias,
+        runId: record.runId,
+        payload: event.payload || {},
+        emittedAt: record.completedAt
       };
-      invocationStore.add(storedInvocation);
-    }
-    updateRuntimeAfterSuccess(node, actorDid, runtime, result, invocationCid || auth.capabilityId, now);
-    return {
-      success: true,
-      stage: "complete",
-      result,
-      capabilityId: auth.capabilityId,
-      invocationCid
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Execution failed";
-    if (invocationStore && invocationCid && invocationData) {
-      const storedInvocation = {
-        cid: invocationCid,
-        invocation: invocationData,
-        invokerDid: actorDid,
-        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-        executedAt: now ? now() : Date.now(),
-        flowId,
-        blockId: node.id,
-        result: "failure",
-        error: message,
-        proofCids: auth.proofCids || []
+      recordBarrierEvent(yDoc, listenerBlockId, entry);
+      if (runtimeMap) {
+        const prev = runtimeMap.get(listenerBlockId) || {};
+        const existing = prev.pendingPayload || {};
+        runtimeMap.set(listenerBlockId, {
+          ...prev,
+          pendingPayload: { ...existing, ...event.payload || {} }
+        });
+      }
+      const allSources = trigger.sources || [];
+      const currentState = readBarrierState(yDoc, listenerBlockId);
+      const requiredSources = allSources.filter((s) => s.optional !== true);
+      const gatingSources = requiredSources.length > 0 ? requiredSources : allSources;
+      const allFired = gatingSources.length > 0 && gatingSources.every((s) => currentState.some((e) => e.sourceBlockId === s.sourceBlockId && e.eventName === s.eventName));
+      if (!allFired) continue;
+      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
+      const id = computeBarrierInvocationId(currentState, listenerBlockId);
+      if (isConsumed(listenerBlockId, id)) continue;
+      const mergedPayload = mergeBarrierPayloads(currentState);
+      const inputs = parseInputs(listenerBlock);
+      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
+      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
+      if (expiresAt && Date.parse(expiresAt) < now) continue;
+      const invocation = {
+        id,
+        triggeringBlockId: sourceBlockId,
+        sourceRunId: record.runId,
+        eventName: `barrier:${allSources.map((s) => s.alias).join("+")}`,
+        eventIndex: 0,
+        payload: mergedPayload,
+        refSnapshots,
+        assigneeDid,
+        emittedAt: record.completedAt,
+        expiresAt
       };
-      invocationStore.add(storedInvocation);
+      queuePendingInvocation(yDoc, listenerBlockId, invocation);
+      clearBarrierState(yDoc, listenerBlockId);
+      if (runtimeMap) {
+        const prev = runtimeMap.get(listenerBlockId) || {};
+        runtimeMap.set(listenerBlockId, {
+          ...prev,
+          pendingPayload: { ...mergedPayload, ...refSnapshots }
+        });
+      }
     }
-    return { success: false, stage: "action", error: message, invocationCid };
   }
-};
-
-// src/core/lib/flowEngine/triggers.ts
-import * as Y from "yjs";
-var RUN_RECORD_AUDIT_TYPE = "block.run";
-function computePendingInvocationId(args) {
-  const { sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex } = args;
-  const input = `${sourceBlockId}:${sourceRunId}:${listenerBlockId}:${eventName}:${eventIndex}`;
-  return `pi-${fnv1a32(input)}`;
-}
-function snapshotInputRefs(inputs, getNodeOutput2) {
-  const snapshots = {};
-  walkRefs(inputs, (ref) => {
-    if (ref.$ref.startsWith("trigger.")) return;
-    const parsed = parseOutputRef(ref.$ref);
-    if (!parsed) return;
-    const output = getNodeOutput2(parsed.nodeId);
-    if (!output) return;
-    snapshots[ref.$ref] = getNestedValue3(output, parsed.fieldPath);
-  });
-  return snapshots;
-}
-function walkRefs(value, visit) {
-  if (isRuntimeRef(value)) {
-    visit(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) walkRefs(item, visit);
-    return;
-  }
-  if (typeof value === "object" && value !== null) {
-    for (const v of Object.values(value)) walkRefs(v, visit);
-  }
-}
-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 getNestedValue3(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
 }
-function fnv1a32(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
+function parseTrigger(block) {
+  const raw = block?.props?.trigger;
+  if (!raw || typeof raw !== "string") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      return parsed;
+    }
+  } catch {
+    warnOnce(`trigger-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.trigger is not valid JSON; trigger ignored`);
   }
-  return (hash >>> 0).toString(16).padStart(8, "0");
+  return null;
 }
-var PENDING_INVOCATIONS_MAP_KEY = "pendingInvocations";
-function getPendingInvocationsMap(yDoc) {
-  return yDoc.getMap(PENDING_INVOCATIONS_MAP_KEY);
+function parseInputs(block) {
+  const raw = block?.props?.inputs;
+  if (!raw || typeof raw !== "string") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+    warnOnce(`inputs-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.inputs is not valid JSON; treated as empty`);
+  }
+  return {};
 }
-function getOrCreateBlockPendingMap(yDoc, blockId) {
-  const outer = getPendingInvocationsMap(yDoc);
-  let inner = outer.get(blockId);
-  if (!inner) {
-    inner = new Y.Map();
-    outer.set(blockId, inner);
+function resolveAssignee(block) {
+  const raw = block?.props?.assignment;
+  if (!raw) return void 0;
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const did = parsed?.assignedActor?.did;
+    return typeof did === "string" && did.length > 0 ? did : void 0;
+  } catch {
+    warnOnce(`assignment-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.assignment is not valid JSON; assignee unresolved`);
+    return void 0;
   }
-  return inner;
 }
-function readPendingInvocations(yDoc, blockId) {
-  const outer = getPendingInvocationsMap(yDoc);
-  const inner = outer.get(blockId);
-  if (!inner) return [];
-  const items = [];
-  inner.forEach((value) => {
-    if (value && typeof value === "object") {
-      items.push(value);
+function computeExpiry(block, emittedAt) {
+  const ttlAbsolute = block?.props?.ttlAbsoluteDueDate;
+  if (typeof ttlAbsolute === "string" && ttlAbsolute) {
+    return ttlAbsolute;
+  }
+  const ttlFromEnablement = block?.props?.ttlFromEnablement;
+  if (typeof ttlFromEnablement === "string" && ttlFromEnablement) {
+    const ms = parseIsoDurationToMs(ttlFromEnablement);
+    if (ms != null) {
+      return new Date(new Date(emittedAt).getTime() + ms).toISOString();
     }
-  });
-  items.sort((a, b) => a.emittedAt.localeCompare(b.emittedAt));
-  return items;
+  }
+  return new Date(new Date(emittedAt).getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
 }
-function queuePendingInvocation(yDoc, listenerBlockId, invocation) {
-  let created = false;
-  yDoc.transact(() => {
-    const inner = getOrCreateBlockPendingMap(yDoc, listenerBlockId);
-    if (inner.has(invocation.id)) return;
-    inner.set(invocation.id, invocation);
-    created = true;
-  });
-  return created;
+function parseIsoDurationToMs(duration) {
+  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(duration);
+  if (!match) return null;
+  const [, d, h, m, s] = match;
+  let ms = 0;
+  if (d) ms += parseInt(d, 10) * 24 * 60 * 60 * 1e3;
+  if (h) ms += parseInt(h, 10) * 60 * 60 * 1e3;
+  if (m) ms += parseInt(m, 10) * 60 * 1e3;
+  if (s) ms += parseInt(s, 10) * 1e3;
+  return ms;
 }
-function removePendingInvocation(yDoc, listenerBlockId, pendingInvocationId) {
-  const outer = getPendingInvocationsMap(yDoc);
-  const inner = outer.get(listenerBlockId);
-  if (!inner) return false;
-  if (!inner.has(pendingInvocationId)) return false;
-  inner.delete(pendingInvocationId);
-  return true;
+function getActionForBlock(block) {
+  const actionType = block?.props?.actionType;
+  if (typeof actionType !== "string") return void 0;
+  return getAction(actionType);
 }
-var BARRIER_STATE_MAP_KEY = "barrierState";
-function getBarrierStateMap(yDoc) {
-  return yDoc.getMap(BARRIER_STATE_MAP_KEY);
+
+// src/core/lib/flowEngine/emitEvents.ts
+function writeRunRecordAndReconcile(editor, blockId, output, events, actorDid, detailsPatch = {}) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return;
+  if (events.length === 0) return;
+  const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const details = {
+    runId,
+    output,
+    events,
+    startedAt: now,
+    completedAt: now,
+    actorDid,
+    ...detailsPatch
+  };
+  appendRunRecord(yDoc, blockId, details, actorDid);
+  reconcilePendingInvocations(editor);
 }
-function getOrCreateListenerBarrierMap(yDoc, listenerBlockId) {
-  const outer = getBarrierStateMap(yDoc);
-  let inner = outer.get(listenerBlockId);
-  if (!inner) {
-    inner = new Y.Map();
-    outer.set(listenerBlockId, inner);
+
+// src/core/lib/flowEngine/utils.ts
+var buildAuthzFromProps = (props) => {
+  const linkedClaimCollectionId = typeof props.linkedClaimCollectionId === "string" ? props.linkedClaimCollectionId.trim() : "";
+  const authz = {};
+  if (linkedClaimCollectionId) {
+    authz.linkedClaim = { collectionId: linkedClaimCollectionId };
   }
-  return inner;
-}
-function recordBarrierEvent(yDoc, listenerBlockId, entry) {
-  let written = false;
-  yDoc.transact(() => {
-    const inner = getOrCreateListenerBarrierMap(yDoc, listenerBlockId);
-    const key = `${entry.sourceBlockId}::${entry.eventName}`;
-    const existing = inner.get(key);
-    if (existing && typeof existing === "object" && existing.runId === entry.runId) return;
-    inner.set(key, entry);
-    written = true;
-  });
-  return written;
-}
-function readBarrierState(yDoc, listenerBlockId) {
-  const outer = getBarrierStateMap(yDoc);
-  const inner = outer.get(listenerBlockId);
-  if (!inner) return [];
-  const entries = [];
-  inner.forEach((value) => {
-    if (value && typeof value === "object") {
-      entries.push(value);
+  return authz;
+};
+var buildFlowNodeFromBlock = (block) => {
+  const base = {
+    id: block.id,
+    type: block.type,
+    props: block.props || {}
+  };
+  const authz = buildAuthzFromProps(block.props || {});
+  return {
+    ...base,
+    ...authz
+  };
+};
+
+// src/core/lib/flowEngine/runtime.ts
+var XERO_WORK_ITEMS_MAP_NAME = "xeroWorkItems";
+var XERO_CONNECTION_MAP_NAME = "xeroConnection";
+var ensureStateObject = (value) => {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return { ...value };
+};
+var createYMapManager = (map) => {
+  return {
+    get: (nodeId) => {
+      const stored = map.get(nodeId);
+      return ensureStateObject(stored);
+    },
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(map.get(nodeId));
+      map.set(nodeId, { ...current, ...updates });
     }
-  });
-  return entries;
-}
-function clearBarrierState(yDoc, listenerBlockId) {
-  const outer = getBarrierStateMap(yDoc);
-  yDoc.transact(() => {
-    outer.delete(listenerBlockId);
-  });
-}
-function computeBarrierInvocationId(entries, listenerBlockId) {
-  const sorted = [...entries].sort((a, b) => a.sourceBlockId.localeCompare(b.sourceBlockId));
-  const input = sorted.map((e) => `${e.sourceBlockId}:${e.runId}:${e.eventName}`).join("|") + `|>${listenerBlockId}`;
-  return `bi-${fnv1a32(input)}`;
-}
-function mergeBarrierPayloads(entries) {
-  const merged = {};
-  for (const entry of entries) {
-    if (entry.alias) {
-      merged[entry.alias] = entry.payload;
-    } else {
-      Object.assign(merged, entry.payload);
+  };
+};
+var createMemoryManager = () => {
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    get: (nodeId) => ensureStateObject(memory.get(nodeId)),
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(memory.get(nodeId));
+      memory.set(nodeId, { ...current, ...updates });
     }
+  };
+};
+var createRuntimeStateManager = (editor) => {
+  if (editor?._yRuntime) {
+    return createYMapManager(editor._yRuntime);
   }
-  return merged;
-}
-function appendRunRecord(yDoc, blockId, details, userId) {
-  const auditMap = yDoc.getMap("auditTrail");
+  return createMemoryManager();
+};
+var createYDocRuntimeManager = (yDoc) => {
+  return createYMapManager(yDoc.getMap("runtime"));
+};
+function clearRuntimeForTemplateClone(yDoc) {
+  const runtime = yDoc.getMap("runtime");
+  const invocations = yDoc.getMap("invocations");
+  const pendingInvocations = yDoc.getMap("pendingInvocations");
+  const agentOutbox = yDoc.getMap("agentOutbox");
+  const agentLeases = yDoc.getMap("agentLeases");
+  const auditTrail = yDoc.getMap("auditTrail");
+  const xeroWorkItems = yDoc.getMap(XERO_WORK_ITEMS_MAP_NAME);
+  const xeroConnection = yDoc.getMap(XERO_CONNECTION_MAP_NAME);
   yDoc.transact(() => {
-    let arr = auditMap.get(blockId);
-    if (!arr) {
-      arr = new Y.Array();
-      auditMap.set(blockId, arr);
-    }
-    const event = {
-      id: `${details.runId}`,
-      blockId,
-      type: RUN_RECORD_AUDIT_TYPE,
-      details,
-      message: void 0,
-      meta: {
-        timestamp: details.completedAt,
-        userId,
-        editable: false
-      }
-    };
-    arr.push([event]);
+    runtime.forEach((_, key) => runtime.delete(key));
+    invocations.forEach((_, key) => invocations.delete(key));
+    pendingInvocations.forEach((_, key) => pendingInvocations.delete(key));
+    agentOutbox.forEach((_, key) => agentOutbox.delete(key));
+    agentLeases.forEach((_, key) => agentLeases.delete(key));
+    auditTrail.forEach((_, key) => auditTrail.delete(key));
+    xeroWorkItems.forEach((_, key) => xeroWorkItems.delete(key));
+    xeroConnection.forEach((_, key) => xeroConnection.delete(key));
   });
 }
-function readRunRecords(yDoc, blockId) {
-  const auditMap = yDoc.getMap("auditTrail");
-  const arr = auditMap.get(blockId);
-  if (!arr) return [];
-  const records = [];
-  arr.forEach((entry) => {
-    if (!entry || typeof entry !== "object") return;
-    const e = entry;
-    if (e.type === RUN_RECORD_AUDIT_TYPE && e.details) {
-      records.push(e.details);
-    }
-  });
-  return records;
+
+// src/core/lib/flowCompiler/resolveRefs.ts
+function resolveRuntimeRefs(nb, getNodeOutput2, triggerContext) {
+  return resolveValue(nb, getNodeOutput2, triggerContext);
 }
-function findFailedListenersForSourceRun(yDoc, sourceBlockId, sourceRunId, listenerBlockIds) {
-  const failures = [];
-  for (const listenerBlockId of listenerBlockIds) {
-    const records = readRunRecords(yDoc, listenerBlockId);
-    for (const record of records) {
-      if (!record.error) continue;
-      if (record.triggeredBy?.sourceBlockId !== sourceBlockId) continue;
-      if (record.fromPendingInvocationId == null) continue;
-      const sourceRunIdField = record.sourceRunId;
-      if (sourceRunIdField && sourceRunIdField !== sourceRunId) continue;
-      failures.push({ listenerBlockId, record });
+function resolveValue(value, getNodeOutput2, triggerContext) {
+  if (isRuntimeRef(value)) {
+    return resolveRef(value.$ref, getNodeOutput2, triggerContext);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, getNodeOutput2, triggerContext));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = resolveValue(val, getNodeOutput2, triggerContext);
     }
+    return result;
   }
-  return failures;
+  return value;
 }
-function replayFailedListenerRun(yDoc, failedRecord, listenerBlockId, originalPayload, originalRefSnapshots, assigneeDid) {
-  if (!failedRecord.triggeredBy) return false;
-  const replayId = `${failedRecord.runId}:replay-${Date.now().toString(36)}`;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const replay = {
-    id: replayId,
-    triggeringBlockId: failedRecord.triggeredBy.sourceBlockId,
-    sourceRunId: failedRecord.sourceRunId || failedRecord.runId,
-    eventName: failedRecord.triggeredBy.eventName,
-    eventIndex: 0,
-    payload: originalPayload,
-    refSnapshots: originalRefSnapshots,
-    assigneeDid,
-    emittedAt: now,
-    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
-  };
-  return queuePendingInvocation(yDoc, listenerBlockId, replay);
+function resolveRef(ref, getNodeOutput2, triggerContext) {
+  if (ref.startsWith("trigger.payload.")) {
+    if (!triggerContext) {
+      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
+    }
+    const fieldPath2 = ref.slice("trigger.payload.".length);
+    return getNestedValue(triggerContext.payload, fieldPath2);
+  }
+  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
+    return triggerContext.refSnapshots[ref];
+  }
+  const outputIndex = ref.indexOf(".output.");
+  if (outputIndex === -1) {
+    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
+  }
+  const nodeId = ref.slice(0, outputIndex);
+  const fieldPath = ref.slice(outputIndex + ".output.".length);
+  const output = getNodeOutput2(nodeId);
+  if (!output) {
+    return void 0;
+  }
+  return getNestedValue(output, fieldPath);
 }
 
-// src/core/lib/flowEngine/reconcile.ts
-var _reconcileRunning = false;
-function reconcilePendingInvocations(editor) {
-  if (_reconcileRunning) return;
-  _reconcileRunning = true;
-  try {
-    _reconcilePendingInvocationsInner(editor);
-  } finally {
-    _reconcileRunning = false;
+// src/core/lib/flowEngine/authorization.ts
+var isAuthorized = async (blockId, actorDid, ucanService, flowUri, schemaVersion) => {
+  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
+  if (policy && !policy.ucanRequired) {
+    return { authorized: true };
   }
-}
-function _reconcilePendingInvocationsInner(editor) {
-  const yDoc = editor._yDoc;
-  if (!yDoc) return;
-  const blocks = editor.document || [];
-  if (blocks.length === 0) return;
-  const listenersBySource = /* @__PURE__ */ new Map();
-  const barrierListenersBySource = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const trigger = parseTrigger(block);
-    if (!trigger) continue;
-    if (trigger.type === "block.event") {
-      if (!trigger.sourceBlockId || !trigger.eventName) continue;
-      const key = `${trigger.sourceBlockId}::${trigger.eventName}`;
-      if (!listenersBySource.has(key)) listenersBySource.set(key, []);
-      listenersBySource.get(key).push({ block, trigger });
-    } else if (trigger.type === "block.event.all" && trigger.sources) {
-      for (const source of trigger.sources) {
-        if (!source.sourceBlockId || !source.eventName) continue;
-        const key = `${source.sourceBlockId}::${source.eventName}`;
-        if (!barrierListenersBySource.has(key)) barrierListenersBySource.set(key, []);
-        barrierListenersBySource.get(key).push({ block, trigger, source });
-      }
+  if (!ucanService) {
+    if (!policy) {
+      return { authorized: true };
     }
+    return {
+      authorized: false,
+      reason: "UCAN service is not configured. This flow version requires UCAN authorization."
+    };
   }
-  if (listenersBySource.size === 0 && barrierListenersBySource.size === 0) return;
-  const runtimeMap = editor._yRuntime;
-  const getNodeOutput2 = (nodeId) => {
-    if (!runtimeMap) return void 0;
-    const state = runtimeMap.get(nodeId);
-    if (!state || typeof state !== "object") return void 0;
-    const out = state.output;
-    return out && typeof out === "object" ? out : void 0;
+  const capability = {
+    can: "flow/block/execute",
+    with: `${flowUri}:${blockId}`
   };
-  for (const block of blocks) {
-    const sourceBlockId = block?.id;
-    if (!sourceBlockId) continue;
-    let hasAnyListener = false;
-    for (const key of listenersBySource.keys()) {
-      if (key.startsWith(`${sourceBlockId}::`)) {
-        hasAnyListener = true;
-        break;
-      }
-    }
-    for (const key of barrierListenersBySource.keys()) {
-      if (key.startsWith(`${sourceBlockId}::`)) {
-        hasAnyListener = true;
-        break;
+  const result = await ucanService.validateDelegationChain(actorDid, capability);
+  if (!result.valid) {
+    return {
+      authorized: false,
+      reason: result.error || "No valid capability chain found"
+    };
+  }
+  const proofCids = result.proofChain?.map((d) => d.cid) || [];
+  return {
+    authorized: true,
+    capabilityId: proofCids[0],
+    proofCids
+  };
+};
+
+// src/core/lib/flowEngine/executor.ts
+var updateRuntimeAfterSuccess = (node, actorDid, runtime, actionResult, invocationCid, now) => {
+  const updates = {
+    submittedByDid: actionResult.submittedByDid || actorDid,
+    evaluationStatus: actionResult.evaluationStatus || "pending",
+    executionTimestamp: now ? now() : Date.now(),
+    lastInvocationCid: invocationCid
+  };
+  if (actionResult.claimId) {
+    updates.claimId = actionResult.claimId;
+  }
+  runtime.update(node.id, updates);
+};
+var executeNode = async ({ node, actorDid, actorType, entityRoomId, context, action, pin }) => {
+  const { runtime, ucanService, invocationStore, flowUri, flowId, schemaVersion, now } = context;
+  const auth = await isAuthorized(node.id, actorDid, ucanService, flowUri, schemaVersion);
+  if (!auth.authorized) {
+    return { success: false, stage: "authorization", error: auth.reason };
+  }
+  if (node.linkedClaim && !node.linkedClaim.collectionId) {
+    return { success: false, stage: "claim", error: "Linked claim collection is required but missing." };
+  }
+  let invocationCid;
+  let invocationData;
+  if (ucanService && auth.proofCids && auth.proofCids.length > 0) {
+    const capability = {
+      can: "flow/block/execute",
+      with: `${flowUri}:${node.id}`
+    };
+    try {
+      const invocationResult = await ucanService.createAndValidateInvocation(
+        {
+          invokerDid: actorDid,
+          invokerType: actorType,
+          entityRoomId,
+          capability,
+          proofs: auth.proofCids,
+          pin
+        },
+        flowId,
+        node.id
+      );
+      if (!invocationResult.valid) {
+        return {
+          success: false,
+          stage: "authorization",
+          error: `Invocation validation failed: ${invocationResult.error}`
+        };
       }
-    }
-    if (!hasAnyListener) continue;
-    const records = readRunRecords(yDoc, sourceBlockId);
-    for (const record of records) {
-      processRunRecord(yDoc, sourceBlockId, record, listenersBySource, getNodeOutput2, runtimeMap);
-      processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, runtimeMap);
+      invocationCid = invocationResult.cid;
+      invocationData = invocationResult.invocation;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to create invocation";
+      return { success: false, stage: "authorization", error: message };
     }
   }
-}
-function processRunRecord(yDoc, sourceBlockId, record, listenersBySource, getNodeOutput2, runtimeMap) {
-  if (!Array.isArray(record.events)) return;
-  record.events.forEach((event, eventIndex) => {
-    if (!event?.name) return;
-    const key = `${sourceBlockId}::${event.name}`;
-    const listeners = listenersBySource.get(key);
-    if (!listeners || listeners.length === 0) return;
-    for (const { block: listenerBlock } of listeners) {
-      const listenerBlockId = listenerBlock.id;
-      if (!listenerBlockId) continue;
-      const id = computePendingInvocationId({
-        sourceBlockId,
-        sourceRunId: record.runId,
-        listenerBlockId,
-        eventName: event.name,
-        eventIndex
-      });
-      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
-      const inputs = parseInputs(listenerBlock);
-      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
-      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
-      const invocation = {
-        id,
-        triggeringBlockId: sourceBlockId,
-        sourceRunId: record.runId,
-        eventName: event.name,
-        eventIndex,
-        payload: event.payload,
-        refSnapshots,
-        assigneeDid,
-        emittedAt: record.completedAt,
-        expiresAt
-      };
-      queuePendingInvocation(yDoc, listenerBlockId, invocation);
-      if (runtimeMap) {
-        const prev = runtimeMap.get(listenerBlockId) || {};
-        runtimeMap.set(listenerBlockId, {
-          ...prev,
-          pendingPayload: { ...event.payload, ...refSnapshots }
-        });
+  try {
+    const result = await action();
+    if (node.linkedClaim && !result.claimId) {
+      if (invocationStore && invocationCid && invocationData) {
+        const storedInvocation = {
+          cid: invocationCid,
+          invocation: invocationData,
+          invokerDid: actorDid,
+          capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+          executedAt: now ? now() : Date.now(),
+          flowId,
+          blockId: node.id,
+          result: "failure",
+          error: "Execution did not return a claimId for linked claim requirement.",
+          proofCids: auth.proofCids || []
+        };
+        invocationStore.add(storedInvocation);
       }
+      return {
+        success: false,
+        stage: "claim",
+        error: "Execution did not return a claimId for linked claim requirement.",
+        invocationCid
+      };
     }
-  });
-}
-function processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, runtimeMap) {
-  if (!Array.isArray(record.events)) return;
-  for (const event of record.events) {
-    if (!event?.name) continue;
-    const key = `${sourceBlockId}::${event.name}`;
-    const listeners = barrierListenersBySource.get(key);
-    if (!listeners || listeners.length === 0) continue;
-    for (const { block: listenerBlock, trigger, source } of listeners) {
-      const listenerBlockId = listenerBlock.id;
-      if (!listenerBlockId) continue;
-      const entry = {
-        sourceBlockId,
-        eventName: event.name,
-        alias: source.alias,
-        runId: record.runId,
-        payload: event.payload || {},
-        emittedAt: record.completedAt
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        blockId: node.id,
+        result: "success",
+        proofCids: auth.proofCids || [],
+        claimId: result.claimId
       };
-      recordBarrierEvent(yDoc, listenerBlockId, entry);
-      if (runtimeMap) {
-        const prev = runtimeMap.get(listenerBlockId) || {};
-        const existing = prev.pendingPayload || {};
-        runtimeMap.set(listenerBlockId, {
-          ...prev,
-          pendingPayload: { ...existing, ...event.payload || {} }
-        });
-      }
-      const allSources = trigger.sources || [];
-      const currentState = readBarrierState(yDoc, listenerBlockId);
-      const requiredSources = allSources.filter((s) => s.optional !== true);
-      const gatingSources = requiredSources.length > 0 ? requiredSources : allSources;
-      const allFired = gatingSources.length > 0 && gatingSources.every((s) => currentState.some((e) => e.sourceBlockId === s.sourceBlockId && e.eventName === s.eventName));
-      if (!allFired) continue;
-      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
-      const id = computeBarrierInvocationId(currentState, listenerBlockId);
-      const mergedPayload = mergeBarrierPayloads(currentState);
-      const inputs = parseInputs(listenerBlock);
-      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
-      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
-      const invocation = {
-        id,
-        triggeringBlockId: sourceBlockId,
-        sourceRunId: record.runId,
-        eventName: `barrier:${allSources.map((s) => s.alias).join("+")}`,
-        eventIndex: 0,
-        payload: mergedPayload,
-        refSnapshots,
-        assigneeDid,
-        emittedAt: record.completedAt,
-        expiresAt
+      invocationStore.add(storedInvocation);
+    }
+    updateRuntimeAfterSuccess(node, actorDid, runtime, result, invocationCid || auth.capabilityId, now);
+    return {
+      success: true,
+      stage: "complete",
+      result,
+      capabilityId: auth.capabilityId,
+      invocationCid
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Execution failed";
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        blockId: node.id,
+        result: "failure",
+        error: message,
+        proofCids: auth.proofCids || []
       };
-      queuePendingInvocation(yDoc, listenerBlockId, invocation);
-      clearBarrierState(yDoc, listenerBlockId);
-      if (runtimeMap) {
-        const prev = runtimeMap.get(listenerBlockId) || {};
-        runtimeMap.set(listenerBlockId, {
-          ...prev,
-          pendingPayload: { ...mergedPayload, ...refSnapshots }
-        });
-      }
+      invocationStore.add(storedInvocation);
     }
+    return { success: false, stage: "action", error: message, invocationCid };
   }
-}
-function parseTrigger(block) {
-  const raw = block?.props?.trigger;
-  if (!raw || typeof raw !== "string") return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
-      return parsed;
+};
+
+// src/core/lib/flowEngine/proof.ts
+var PROOF_MISSING_CODE = "PROOF_MISSING";
+function getOutputValue(output, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc && typeof acc === "object") return acc[key];
+    return void 0;
+  }, output);
+}
+function isProofValue(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "number") return !Number.isNaN(value);
+  return !!value;
+}
+function validateActionProof(action, output) {
+  const proof = action.proof;
+  if (proof === "none") return { valid: true };
+  if (proof === void 0) {
+    if (action.sideEffect) {
+      return {
+        valid: false,
+        reason: `Action '${action.type}' has a side effect but declares no proof of execution. Declare proof (or 'none') on its ActionDefinition.`
+      };
     }
-  } catch {
+    return { valid: true };
   }
-  return null;
-}
-function parseInputs(block) {
-  const raw = block?.props?.inputs;
-  if (!raw || typeof raw !== "string") return {};
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
+  if ("validate" in proof) {
+    let valid = false;
+    try {
+      valid = proof.validate(output);
+    } catch {
+      valid = false;
+    }
+    return valid ? { valid: true } : { valid: false, reason: `Action '${action.type}' returned success but its proof validator rejected the output.` };
   }
-  return {};
+  const satisfied = proof.fields.some((field) => isProofValue(getOutputValue(output, field)));
+  if (satisfied) return { valid: true };
+  return {
+    valid: false,
+    reason: `Action '${action.type}' returned success without proof. Expected at least one of [${proof.fields.join(", ")}] in the output. Check the handler logs.`
+  };
 }
-function resolveAssignee(block) {
-  const raw = block?.props?.assignment;
-  if (!raw) return void 0;
-  try {
-    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
-    const did = parsed?.assignedActor?.did;
-    return typeof did === "string" && did.length > 0 ? did : void 0;
-  } catch {
-    return void 0;
+
+// src/core/lib/flowEngine/verifiedCompletion.ts
+function verifyCompletion(params) {
+  const { runtime, blockId, actionType, getInvocation, schemaVersion } = params;
+  if (!runtime || runtime.state !== "completed") {
+    return { status: "not_completed" };
   }
-}
-function computeExpiry(block, emittedAt) {
-  const ttlAbsolute = block?.props?.ttlAbsoluteDueDate;
-  if (typeof ttlAbsolute === "string" && ttlAbsolute) {
-    return ttlAbsolute;
+  if (runtime.manuallyVerified === true) {
+    return { status: "verified" };
   }
-  const ttlFromEnablement = block?.props?.ttlFromEnablement;
-  if (typeof ttlFromEnablement === "string" && ttlFromEnablement) {
-    const ms = parseIsoDurationToMs(ttlFromEnablement);
-    if (ms != null) {
-      return new Date(new Date(emittedAt).getTime() + ms).toISOString();
+  if (actionType && isRepeatableAction(actionType)) {
+    return { status: "verified" };
+  }
+  if (actionType) {
+    const action = getAction(actionType);
+    if (action) {
+      const proofCheck = validateActionProof(action, runtime.output || {});
+      if (!proofCheck.valid) {
+        return { status: "unverified", reason: proofCheck.reason || "Completed without proof of execution." };
+      }
     }
   }
-  return new Date(new Date(emittedAt).getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
-}
-function parseIsoDurationToMs(duration) {
-  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(duration);
-  if (!match) return null;
-  const [, d, h, m, s] = match;
-  let ms = 0;
-  if (d) ms += parseInt(d, 10) * 24 * 60 * 60 * 1e3;
-  if (h) ms += parseInt(h, 10) * 60 * 60 * 1e3;
-  if (m) ms += parseInt(m, 10) * 60 * 1e3;
-  if (s) ms += parseInt(s, 10) * 1e3;
-  return ms;
+  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
+  if (!policy?.ucanRequired) {
+    return { status: "verified" };
+  }
+  const invocationCid = runtime.lastInvocationCid;
+  if (!invocationCid) {
+    return { status: "unverified", reason: "Completed without an invocation record on a UCAN-enforced flow." };
+  }
+  if (!getInvocation) {
+    return { status: "unverified", reason: "No invocation store available to verify the completion." };
+  }
+  const invocation = getInvocation(invocationCid);
+  if (!invocation) {
+    return { status: "unverified", reason: `Invocation ${invocationCid} not found in the invocation store.` };
+  }
+  if (invocation.result !== "success") {
+    return { status: "unverified", reason: "Completion references a failed invocation." };
+  }
+  if (invocation.blockId && invocation.blockId !== blockId) {
+    return { status: "unverified", reason: "Completion references an invocation for a different block." };
+  }
+  return { status: "verified" };
 }
-function getActionForBlock(block) {
-  const actionType = block?.props?.actionType;
-  if (typeof actionType !== "string") return void 0;
-  return getAction(actionType);
+function isVerifiedCompletion(params) {
+  return verifyCompletion(params).status === "verified";
 }
 
 // src/core/lib/ucanDelegationStore.ts
@@ -10187,26 +10582,6 @@ var createMemoryInvocationStore = () => {
   };
 };
 
-// src/core/lib/flowEngine/emitEvents.ts
-function writeRunRecordAndReconcile(editor, blockId, output, events, actorDid, detailsPatch = {}) {
-  const yDoc = editor._yDoc;
-  if (!yDoc) return;
-  if (events.length === 0) return;
-  const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const details = {
-    runId,
-    output,
-    events,
-    startedAt: now,
-    completedAt: now,
-    actorDid,
-    ...detailsPatch
-  };
-  appendRunRecord(yDoc, blockId, details, actorDid);
-  reconcilePendingInvocations(editor);
-}
-
 // src/core/lib/flowEngine/actionExecutor.ts
 import * as Y3 from "yjs";
 
@@ -10406,6 +10781,46 @@ async function reconcileActionReadBack(params) {
       readBack: failedReadBack
     };
   }
+  const readBackActionType = readBack.actionType || readBack.kind;
+  const actionDef = readBackActionType ? getAction(readBackActionType) : void 0;
+  if (actionDef) {
+    const proofCheck = validateActionProof(actionDef, finalOutput || {});
+    if (!proofCheck.valid) {
+      const message = proofCheck.reason || "Read-back resolved completed without proof of execution.";
+      const proofFailedReadBack = {
+        ...nextReadBack,
+        terminalAt: checkedIso
+      };
+      runtime.update(params.blockId, {
+        state: actionDef.sideEffect ? "needs_verification" : "failed",
+        output: finalOutput,
+        error: { message, code: PROOF_MISSING_CODE, at: checkedAt },
+        readBack: proofFailedReadBack
+      });
+      const failedRunId = writeReconciliationRunRecord({
+        yDoc,
+        editor: getReconcileEditor(params, yDoc, editor),
+        blockId: params.blockId,
+        actorDid,
+        output: finalOutput,
+        events,
+        readBack: proofFailedReadBack,
+        error: { message, code: PROOF_MISSING_CODE },
+        now
+      });
+      return {
+        success: false,
+        blockId: params.blockId,
+        state: "failed",
+        output: finalOutput,
+        events,
+        error: message,
+        runId: failedRunId,
+        pendingInvocationRemoved: false,
+        readBack: proofFailedReadBack
+      };
+    }
+  }
   const completedReadBack = {
     ...nextReadBack,
     terminalAt: checkedIso
@@ -10457,6 +10872,7 @@ function parseInputs2(value) {
     const parsed = JSON.parse(value);
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
+    warnOnce(`executor-inputs-parse:${value}`, `[flow-config] saved block inputs are not valid JSON; treated as empty`);
     return {};
   }
 }
@@ -10638,6 +11054,8 @@ async function executeActionBlock(params) {
   let readBack;
   let rawReadBack;
   let requestedAwaitingReadBack = false;
+  let proofFailureReason = null;
+  let proofFailureOutput;
   const startedAt = now();
   runtime.update(blockId, {
     state: "running",
@@ -10677,6 +11095,13 @@ async function executeActionBlock(params) {
       if (result.completion?.state === "awaiting_readback") {
         requestedAwaitingReadBack = true;
         rawReadBack = result.completion.readBack;
+      } else {
+        const proofCheck = validateActionProof(action, result.output || {});
+        if (!proofCheck.valid) {
+          proofFailureReason = proofCheck.reason || "Action returned success without proof of execution.";
+          proofFailureOutput = result.output || {};
+          throw new Error(proofFailureReason);
+        }
       }
       return {
         payload: result.output,
@@ -10687,6 +11112,27 @@ async function executeActionBlock(params) {
   });
   if (!outcome.success) {
     const message = outcome.error || "Action execution failed";
+    if (proofFailureReason) {
+      const proofFailureState = action.sideEffect ? "needs_verification" : "failed";
+      runtime.update(blockId, {
+        state: proofFailureState,
+        output: proofFailureOutput,
+        error: { message, code: PROOF_MISSING_CODE, at: now() }
+      });
+      return {
+        ...buildFailureResult({
+          blockId,
+          actionType,
+          stage: outcome.stage,
+          error: message,
+          pendingInvocation: inputBuild.pendingInvocation
+        }),
+        completionState: proofFailureState === "needs_verification" ? "needs_verification" : "failed",
+        output: proofFailureOutput,
+        invocationCid: outcome.invocationCid,
+        capabilityId: outcome.capabilityId
+      };
+    }
     updateRuntimeFailure(runtime, blockId, message, now);
     return {
       ...buildFailureResult({
@@ -10754,6 +11200,29 @@ async function executeActionBlock(params) {
   };
 }
 
+// src/core/lib/flowEngine/validateBlockConfig.ts
+function validateBlockConfig(block) {
+  const issues = [];
+  if (!block?.props) return issues;
+  const checkJson = (propName, value, expectObject = true) => {
+    if (value == null || value === "") return;
+    if (typeof value !== "string") return;
+    try {
+      const parsed = JSON.parse(value);
+      if (expectObject && (parsed == null || typeof parsed !== "object")) {
+        issues.push(`${propName} is valid JSON but not an object`);
+      }
+    } catch {
+      issues.push(`${propName} is not valid JSON`);
+    }
+  };
+  checkJson("inputs", block.props.inputs);
+  checkJson("trigger", block.props.trigger);
+  checkJson("assignment", block.props.assignment);
+  checkJson("conditions", block.props.conditions);
+  return issues;
+}
+
 // src/core/lib/flowEngine/migration.ts
 var MIGRATION_REGISTRY = {};
 function registerMigration(definition) {
@@ -12330,20 +12799,30 @@ function classifyBlockerCause(block, runtime) {
   }
   return void 0;
 }
-function classifyNodeState({ block, runtime, now, pendingInvocationCount = 0 }) {
+function classifyNodeState({
+  block,
+  runtime,
+  now,
+  pendingInvocationCount = 0,
+  completionVerification,
+  isRepeatable = false
+}) {
+  if (isRepeatable && runtime.state === "completed") return "Active";
+  if (runtime.state === "completed" && completionVerification?.status === "unverified") return "Blocked";
   if (runtime.state === "completed" || runtime.state === "cancelled") return "Done";
+  if (runtime.state === "needs_verification") return "Blocked";
   if (runtime.state === "failed" || runtime.error) return "Blocked";
   const dueAt = getDueAt(block);
   if (dueAt != null && dueAt <= now) return "Overdue";
   if (pendingInvocationCount > 0) return "Pending";
   return "Pending";
 }
-function snapshotNode(block, runtime, now, pendingInvocationCount = 0) {
+function snapshotNode(block, runtime, now, pendingInvocationCount = 0, completionVerification, isRepeatable = false) {
   const nodeId = getBlockId(block);
   if (!nodeId) {
     throw new Error("Cannot snapshot a block without an id");
   }
-  const publicState = classifyNodeState({ block, runtime, now, pendingInvocationCount });
+  const publicState = classifyNodeState({ block, runtime, now, pendingInvocationCount, completionVerification, isRepeatable });
   const dueAt = getDueAt(block);
   const assigneeDid = getAssigneeDid(block);
   const snapshot = {
@@ -12358,7 +12837,13 @@ function snapshotNode(block, runtime, now, pendingInvocationCount = 0) {
   const title = getBlockTitle(block);
   if (title) snapshot.title = title;
   if (publicState === "Blocked") {
-    snapshot.blockerCause = classifyBlockerCause(block, runtime) || "unknown";
+    if (runtime.state === "needs_verification") {
+      snapshot.blockerCause = "awaiting_verification";
+    } else if (runtime.state === "completed" && completionVerification?.status === "unverified") {
+      snapshot.blockerCause = "unverified_completion";
+    } else {
+      snapshot.blockerCause = classifyBlockerCause(block, runtime) || "unknown";
+    }
   }
   if (assigneeDid) snapshot.assigneeDid = assigneeDid;
   if (dueAt != null) snapshot.dueAt = dueAt;
@@ -12549,7 +13034,7 @@ function statusForResult(result) {
 function planForSnapshot(context, options, block, snapshot) {
   const queued = [];
   const actionType = getBlockActionType(block);
-  if (snapshot.publicState === "Done") {
+  const queueClaimUdidWatch = () => {
     const runtime = snapshot.runtime;
     if (actionType === "qi/claim.submit" && runtime.output?.claimId && !runtime.output?.udid) {
       const command = queueIfAuthorized(context, options, "watch_udid", snapshot.nodeId, "Claim submitted but UDID is not yet observed", {
@@ -12558,6 +13043,13 @@ function planForSnapshot(context, options, block, snapshot) {
       });
       if (command) queued.push(command);
     }
+  };
+  if (snapshot.publicState === "Active") {
+    queueClaimUdidWatch();
+    return queued;
+  }
+  if (snapshot.publicState === "Done") {
+    queueClaimUdidWatch();
     return queued;
   }
   if (snapshot.publicState === "Overdue") {
@@ -12641,11 +13133,24 @@ function planRalphLoopCommands(context, options = {}) {
   const blocks = getBlocks(context);
   const snapshots = [];
   const queuedCommands = [];
+  const invocationsMap = context.yDoc.getMap("invocations");
+  const schemaVersionRaw = context.yDoc.getMap("root").get("schema_version");
+  const schemaVersion = typeof schemaVersionRaw === "string" ? schemaVersionRaw : void 0;
+  const getInvocation = (cid) => invocationsMap.get(cid);
   for (const block of blocks) {
     const nodeId = getBlockId(block);
     if (!nodeId) continue;
     const pendingInvocationCount = readPendingInvocations(context.yDoc, nodeId).length;
-    const snapshot = snapshotNode(block, getRuntime3(context.yDoc, nodeId), now, pendingInvocationCount);
+    const runtime = getRuntime3(context.yDoc, nodeId);
+    const actionType = getBlockActionType(block);
+    const completionVerification = verifyCompletion({
+      runtime,
+      blockId: nodeId,
+      actionType,
+      getInvocation,
+      schemaVersion
+    });
+    const snapshot = snapshotNode(block, runtime, now, pendingInvocationCount, completionVerification, isRepeatableAction(actionType));
     snapshots.push(snapshot);
     queuedCommands.push(...planForSnapshot(context, options, block, snapshot));
   }
@@ -13225,14 +13730,20 @@ var FlowAgentService = class {
 };
 
 export {
+  warnOnce,
+  STEP_COMPLETED_EVENT_NAME,
+  STEP_COMPLETED_EVENT,
   resolveActionType,
   registerAction,
   getAction,
   getAllActions,
+  isRepeatableAction,
+  getAliasEntries,
   hasAction,
   getActionByCan,
   getEventsForBlock,
   getOutputSchemaForBlock,
+  generateActionManifest,
   canToType,
   typeToCan,
   getAllCanMappings,
@@ -13256,6 +13767,7 @@ export {
   serializeXeroPaymentCreateInputs,
   parseReferences,
   resolveSingleReference,
+  resolveReferencesDetailed,
   resolveReferences,
   hasReferences,
   createReference,
@@ -13292,15 +13804,7 @@ export {
   formatCoin2 as formatCoin,
   formatCoinAmount,
   createUcanService,
-  buildAuthzFromProps,
-  buildFlowNodeFromBlock,
-  createRuntimeStateManager,
-  clearRuntimeForTemplateClone,
   isRuntimeRef,
-  resolveRuntimeRefs,
-  LATEST_VERSION,
-  isAuthorized,
-  executeNode,
   RUN_RECORD_AUDIT_TYPE,
   computePendingInvocationId,
   snapshotInputRefs,
@@ -13313,16 +13817,32 @@ export {
   readRunRecords,
   findFailedListenersForSourceRun,
   replayFailedListenerRun,
+  VERSION_MANIFEST,
+  LATEST_VERSION,
+  getVersionPolicy,
+  isVersionAtLeast,
   reconcilePendingInvocations,
   getActionForBlock,
+  writeRunRecordAndReconcile,
+  buildAuthzFromProps,
+  buildFlowNodeFromBlock,
+  createRuntimeStateManager,
+  clearRuntimeForTemplateClone,
+  resolveRuntimeRefs,
+  isAuthorized,
+  executeNode,
+  PROOF_MISSING_CODE,
+  validateActionProof,
   reconcileActionReadBack,
   buildActionRunInputs,
   executeActionBlock,
+  verifyCompletion,
+  isVerifiedCompletion,
+  validateBlockConfig,
   createUcanDelegationStore,
   createMemoryUcanDelegationStore,
   createInvocationStore,
   createMemoryInvocationStore,
-  writeRunRecordAndReconcile,
   compileBlockProps,
   COMPILED_BLOCK_TYPE,
   toEvaluatorOperator,
@@ -13374,4 +13894,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-YWZJYSOP.js.map
+//# sourceMappingURL=chunk-5TJK6JKV.js.map