@ixo/editor 5.40.0 → 6.0.0

package/dist/core/index.d.ts

@@ -1,7 +1,7 @@
-import { a5 as ActionDefinition, a6 as ActionEventDefinition, a7 as OutputSchemaField, a8 as ActionServices, a9 as CompiledBlock, v as CompiledFlow, aa as CompiledEdge, Z as FlowAgentCommand, $ as FlowAgentContext, _ as FlowAgentCommandResult, a0 as FlowAgentExecutor, a2 as FlowAgentNodeSnapshot, ab as FlowAgentBlockerCause, a3 as FlowAgentPublicNodeState } from '../store-B-2A-Tlv.js';
-export { am as AcquireFlowAgentLeaseParams, ad as ActionContext, ae as ActionResult, aA as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, X as BuildFlowAgentContextParams, aD as CompiledFlowNode, C as CompilerRegistry, az as ConditionRef, an as CreateAgentCommandParams, ao as EvaluateFlowAgentPolicyParams, E as ExecuteNodeParams, f as ExecutionContext, d as ExecutionOutcome, Y as FlowAgentActor, ar as FlowAgentCommandBase, as as FlowAgentCommandStatus, at as FlowAgentCommandType, a1 as FlowAgentLease, au as FlowAgentLedgerEvent, av as FlowAgentLedgerEventType, aw as FlowAgentMaps, ap as FlowAgentOrchestratorOptions, ax as FlowAgentPolicyDecision, ay as FlowAgentRunPhase, x as FlowAgentService, aq as FlowAgentServiceOptions, a4 as FlowAgentTickResult, u as FlowCapability, F as FlowRuntimeStateManager, w as FlowStrategy, M as MergeResult, N as NodeActionResult, R as ReadFlowOptions, q as ReadFlowResult, aC as RuntimeRef, S as SetupFlowOptions, p as SetupFlowResult, aB as TTLConstraint, aE as TriggerSpec, y as acquireFlowAgentLease, z as appendAgentLedgerEvent, a as buildAuthzFromProps, D as buildFlowAgentContext, b as buildFlowNodeFromBlock, af as canMatches, G as cleanupExpiredFlowAgentLeases, ac as clearRuntimeForTemplateClone, l as compileBaseUcanFlow, ag as computeAgentCommandId, H as createAgentCommand, c as createRuntimeStateManager, o as decompileToBaseUcanFlow, I as evaluateFlowAgentPolicy, e as executeNode, J as executeQueuedAgentCommands, k as getActiveEditor, K as getFlowAgentMaps, i as isAuthorized, ah as isCapabilityMatch, ai as isExternalMutation, aF as isRuntimeRef, n as mergeCompiledFlows, L as planRalphLoopCommands, O as queueAgentCommand, P as readAgentLedgerEvents, m as readCompiledFlowFromYDoc, h as readFlow, r as readFlowAsBaseUcan, g as readFlowFromEditor, Q as readQueuedAgentCommands, T as releaseFlowAgentLease, aj as requiredCapabilityForCommand, ak as resourceMatches, j as setActiveEditor, s as setupFlowFromBaseUcan, U as tickFlowAgent, al as updateAgentCommand, V as validateAgentCommand, W as validateFlowAgentLease } from '../store-B-2A-Tlv.js';
-import { a4 as IxoEditorType, a5 as FlowNodeRuntimeState, f as UcanService, U as UcanDelegationStore, S as StoredDelegation, I as InvocationStore, a6 as FlowMetadata, a7 as FlowNode } from '../index-B4Qe8xbv.js';
-export { af as ActionReadBackMetadata, a9 as ClaimCollectionURI, am as CreateDelegationParams, an as CreateInvocationParams, al as CreateRootDelegationParams, a8 as DID, D as DelegationChainValidationResult, k as DelegationGrant, aa as EvaluationStatus, aj as ExecutionWithInvocationResult, ak as FindProofsResult, ac as FlowNodeAuthzExtension, ag as FlowNodeBase, ah as InvocationRequest, ai as InvocationResult, ab as LinkedClaim, ad as NodeState, ae as ReadBackTerminalState, j as StoredInvocation, i as UcanCapability, g as UcanServiceConfig, h as UcanServiceHandlers, b as createInvocationStore, d as createMemoryInvocationStore, a as createMemoryUcanDelegationStore, c as createUcanDelegationStore, e as createUcanService } from '../index-B4Qe8xbv.js';
+import { a5 as ActionDefinition, a6 as ActionEventDefinition, a7 as OutputSchemaField, a8 as ActionServices, a9 as ActionProofDeclaration, aa as RunRecordDetails, ab as CompiledBlock, v as CompiledFlow, ac as CompiledEdge, Z as FlowAgentCommand, $ as FlowAgentContext, ad as ActionHandlers, _ as FlowAgentCommandResult, a0 as FlowAgentExecutor, a2 as FlowAgentNodeSnapshot, ae as FlowAgentBlockerCause, a3 as FlowAgentPublicNodeState } from '../store-C_KCYNzv.js';
+export { aP as AcquireFlowAgentLeaseParams, ag as ActionContext, at as ActionResult, b1 as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, ak as BidService, X as BuildFlowAgentContextParams, ar as CarbonService, al as ClaimService, am as CollectionService, an as CollectionUsersService, b4 as CompiledFlowNode, C as CompilerRegistry, b0 as ConditionRef, aQ as CreateAgentCommandParams, ai as EmailService, as as EntityService, aR as EvaluateFlowAgentPolicyParams, E as ExecuteNodeParams, f as ExecutionContext, d as ExecutionOutcome, aH as FailedListenerRun, Y as FlowAgentActor, aU as FlowAgentCommandBase, aV as FlowAgentCommandStatus, aW as FlowAgentCommandType, a1 as FlowAgentLease, aX as FlowAgentLedgerEvent, aY as FlowAgentLedgerEventType, aZ as FlowAgentMaps, aS as FlowAgentOrchestratorOptions, a_ as FlowAgentPolicyDecision, a$ as FlowAgentRunPhase, x as FlowAgentService, aT as FlowAgentServiceOptions, a4 as FlowAgentTickResult, u as FlowCapability, F as FlowRuntimeStateManager, w as FlowStrategy, ah as HttpService, ap as IntegrationsService, ao as MatrixCredentialService, M as MergeResult, N as NodeActionResult, aj as NotifyService, aq as OracleService, aG as PendingInvocation, aF as RUN_RECORD_AUDIT_TYPE, R as ReadFlowOptions, q as ReadFlowResult, b3 as RuntimeRef, S as SetupFlowOptions, p as SetupFlowResult, b2 as TTLConstraint, b5 as TriggerSpec, y as acquireFlowAgentLease, z as appendAgentLedgerEvent, au as appendRunRecord, a as buildAuthzFromProps, D as buildFlowAgentContext, b as buildFlowNodeFromBlock, aI as canMatches, G as cleanupExpiredFlowAgentLeases, af as clearRuntimeForTemplateClone, l as compileBaseUcanFlow, aJ as computeAgentCommandId, aE as computePendingInvocationId, H as createAgentCommand, c as createRuntimeStateManager, o as decompileToBaseUcanFlow, I as evaluateFlowAgentPolicy, e as executeNode, J as executeQueuedAgentCommands, aB as findFailedListenersForSourceRun, k as getActiveEditor, K as getFlowAgentMaps, ax as getOrCreateBlockPendingMap, aw as getPendingInvocationsMap, i as isAuthorized, aK as isCapabilityMatch, aL as isExternalMutation, b6 as isRuntimeRef, n as mergeCompiledFlows, L as planRalphLoopCommands, O as queueAgentCommand, az as queuePendingInvocation, P as readAgentLedgerEvents, m as readCompiledFlowFromYDoc, h as readFlow, r as readFlowAsBaseUcan, g as readFlowFromEditor, ay as readPendingInvocations, Q as readQueuedAgentCommands, av as readRunRecords, T as releaseFlowAgentLease, aA as removePendingInvocation, aC as replayFailedListenerRun, aM as requiredCapabilityForCommand, aN as resourceMatches, j as setActiveEditor, s as setupFlowFromBaseUcan, aD as snapshotInputRefs, U as tickFlowAgent, aO as updateAgentCommand, V as validateAgentCommand, W as validateFlowAgentLease } from '../store-C_KCYNzv.js';
+import { a4 as FlowNodeRuntimeState, j as StoredInvocation, a5 as IxoEditorType, f as UcanService, U as UcanDelegationStore, S as StoredDelegation, I as InvocationStore, a6 as FlowMetadata, a7 as FlowNode } from '../index-DL8Yh3Xu.js';
+export { af as ActionReadBackMetadata, a9 as ClaimCollectionURI, am as CreateDelegationParams, an as CreateInvocationParams, al as CreateRootDelegationParams, a8 as DID, D as DelegationChainValidationResult, k as DelegationGrant, aa as EvaluationStatus, aj as ExecutionWithInvocationResult, ak as FindProofsResult, ac as FlowNodeAuthzExtension, ag as FlowNodeBase, ah as InvocationRequest, ai as InvocationResult, ab as LinkedClaim, ad as NodeState, ae as ReadBackTerminalState, i as UcanCapability, g as UcanServiceConfig, h as UcanServiceHandlers, b as createInvocationStore, d as createMemoryInvocationStore, a as createMemoryUcanDelegationStore, c as createUcanDelegationStore, e as createUcanService } from '../index-DL8Yh3Xu.js';
 import * as Y from 'yjs';
 import { Doc } from 'yjs';
 import 'matrix-js-sdk';
@@ -22,6 +22,8 @@ declare const STEP_COMPLETED_EVENT: ActionEventDefinition;
 declare function registerAction<TInputs extends Record<string, any> = Record<string, any>>(definition: ActionDefinition<TInputs>): void;
 declare function getAction(type: string): ActionDefinition | undefined;
 declare function getAllActions(): ActionDefinition[];
+/** All (alias → canonical type) pairs, for manifest generation and consistency checks. */
+declare function getAliasEntries(): Array<[string, string]>;
 declare function hasAction(type: string): boolean;
 /** Look up an action by its UCAN `can` ability string, e.g., "bid/submit". */
 declare function getActionByCan(can: string): ActionDefinition | undefined;
@@ -46,6 +48,54 @@ declare function getEventsForBlock(action: ActionDefinition | undefined, inputs:
  */
 declare function getOutputSchemaForBlock(action: ActionDefinition | undefined, inputs: unknown): OutputSchemaField[];
 
+/**
+ * Serializable proof declaration: custom `validate` functions can't cross a
+ * JSON boundary, so they are represented as `{ kind: 'custom' }` — consumers
+ * know a proof exists and is enforced kernel-side, without its logic.
+ */
+type ManifestProofDeclaration = {
+    kind: 'none';
+} | {
+    kind: 'fields';
+    fields: string[];
+} | {
+    kind: 'custom';
+};
+interface ActionManifestEntry {
+    type: string;
+    /** Legacy names that resolve to this canonical type. */
+    aliases: string[];
+    can?: string;
+    sideEffect: boolean;
+    defaultRequiresConfirmation: boolean;
+    requiredCapability?: string;
+    proof: ManifestProofDeclaration;
+    /** JSON Schema for the action's inputs, when declared. */
+    inputSchema?: object;
+    /** Static output schema. Actions with dynamic schemas also set hasDynamicOutputSchema. */
+    outputSchema?: OutputSchemaField[];
+    /** Static event vocabulary. Actions with dynamic events also set hasDynamicEvents. */
+    events?: Array<Pick<ActionEventDefinition, 'name' | 'displayName' | 'description' | 'payloadSchema'>>;
+    hasDynamicEvents: boolean;
+    hasDynamicOutputSchema: boolean;
+    eligibleForEventTrigger: boolean;
+}
+interface ActionManifest {
+    /** Schema version of the manifest format itself. */
+    manifestVersion: '1';
+    actions: ActionManifestEntry[];
+}
+/**
+ * Generate the machine-readable action contract from the live registry.
+ *
+ * This is the single artifact external actors (the flow-manager oracle,
+ * third-party agentic Oracle actors) implement against, replacing
+ * hand-maintained copies of input contracts. It is emitted to
+ * `dist/action-manifest.json` at build time and also callable at runtime
+ * from `@ixo/editor/core`.
+ */
+declare function generateActionManifest(): ActionManifest;
+
 /**
  * Bidirectional mapping between UCAN `can` vocabulary and registry `type` strings.
  * Derived mechanically: strip "qi/", replace "." with "/".
@@ -60,13 +110,6 @@ declare function getAllCanMappings(): ReadonlyArray<{
     type: string;
 }>;
 
-/**
- * Builds an ActionServices map from BlocknoteHandlers.
- * Used by block components to bridge existing DI into registry calls.
- *
- * The handlers parameter is typed as `any` to avoid a circular dependency
- * between core and mantine layers — BlocknoteHandlers is defined in mantine/context.
- */
 declare function buildServicesFromHandlers(handlers: any): ActionServices;
 
 /**
@@ -110,249 +153,68 @@ interface TriggerResolutionContext {
  */
 declare function resolveRuntimeRefs(nb: Record<string, unknown>, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): Record<string, unknown>;
 
-/**
- * Run record stored in the audit trail as `type: 'block.run'`.
- *
- * Per Phase 0 #2 (eng review pass 2), run records are NOT a parallel
- * `_yRunHistory` structure — they ride on the existing `auditTrail` Y.Map
- * via `useAuditTrail.addEvent`. The shape below is what goes into the
- * audit trail event's `details` field.
- *
- * See `docs/events-and-triggers-plan.md` §3.4, §18, §19.
- */
-interface RunRecordDetails {
-    /** Stable identifier for this run, deterministic from invocation context. */
-    runId: string;
-    /** Action's output. */
-    output: Record<string, unknown>;
-    /**
-     * Events the action emitted on this run. Persisted as part of the run
-     * record so the reconciliation loop can process them idempotently — even
-     * across page refreshes and across multiple clients.
-     */
-    events: Array<{
-        name: string;
-        payload: Record<string, unknown>;
-    }>;
-    /** ISO timestamp when the action started. */
-    startedAt: string;
-    /** ISO timestamp when the action completed (success or failure). */
-    completedAt: string;
-    /** DID of the actor who signed the invocation that produced this run. */
-    actorDid: string;
-    /** UCAN invocation CID when execution produced one. */
-    invocationCid?: string;
-    /** Capability/proof CID used when no invocation CID was produced. */
-    capabilityId?: string;
-    /** Optional error if the run failed. */
-    error?: {
-        message: string;
-        code?: string;
-    };
-    /** External read-back metadata associated with this run or reconciliation. */
-    readBack?: Record<string, unknown>;
-    /** True when this audit entry was written by external read-back reconciliation. */
-    reconciled?: boolean;
-    /**
-     * If this run was triggered by a pending invocation (i.e. it's a listener
-     * run), the id of that pending invocation. Used to dedup replays and trace
-     * causality back through `triggeredBy`.
-     */
-    fromPendingInvocationId?: string;
-    /**
-     * If this run is a listener run, the (sourceBlockId, eventName) that
-     * caused it. Used by the failure visibility surface to attribute failures
-     * back to the source block (CP-1).
-     */
-    triggeredBy?: {
-        sourceBlockId: string;
-        eventName: string;
-    };
-    /** Source run id for listener runs, stored explicitly for failure lookups. */
-    sourceRunId?: string;
+declare const PROOF_MISSING_CODE = "PROOF_MISSING";
+interface ProofValidationResult {
+    valid: boolean;
+    reason?: string;
 }
-declare const RUN_RECORD_AUDIT_TYPE = "block.run";
 /**
- * Pending invocation queued on a listener block.
+ * Validate a successful action run's output against the action's proof
+ * declaration. Called by `executeActionBlock` before writing
+ * `state: 'completed'` — success without proof becomes a failure.
  *
- * Stored in `_yPendingInvocations: Y.Map<blockId, Y.Map<id, PendingInvocation>>`.
- *
- * The id is deterministic — derived from
- * `(sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex)` —
- * so the reconciliation loop can run idempotently from multiple clients
- * without producing duplicates.
- *
- * See `docs/events-and-triggers-plan.md` §3.4, §3.5.1, §18.
+ * A `sideEffect: true` action with no declaration fails closed; a
+ * side-effect-free action with no declaration is tolerated (legacy
+ * consumer-registered actions) but should declare `'none'` explicitly.
  */
-interface PendingInvocation {
-    /** Deterministic id, see `computePendingInvocationId`. */
-    id: string;
-    /** Block that emitted the event. */
-    triggeringBlockId: string;
-    /** Run id of the triggering source run, used for the deterministic id. */
-    sourceRunId: string;
-    /** Event name from the source action's vocabulary. */
-    eventName: string;
-    /** Event index within the source run's `events` array (a single run can emit multiple). */
-    eventIndex: number;
-    /**
-     * The frozen event payload, captured by value at emission time. The
-     * assignee invokes the listener against this payload, not against the
-     * source block's current state. This is the property that makes the
-     * Sally → Mike scenario produce 10 distinct emails even when Mike acts
-     * on them all hours later.
-     */
-    payload: Record<string, unknown>;
-    /**
-     * Snapshots of `nodeId.output.*` ref values that the listener's inputs
-     * reference, captured at queue time. Keyed by the full ref string.
-     *
-     * §3.5.1: ref snapshots are the load-bearing fix for the lag-time
-     * overwrite scenario. If a listener references a non-trigger block's
-     * output (e.g. `evaluateBlock.output.claimId`), that value is captured
-     * here at queue time. Resolution at invocation time prefers the snapshot
-     * over current state, so multiple queued invocations don't drift when
-     * the source re-runs.
-     */
-    refSnapshots: Record<string, unknown>;
-    /** DID of the assigned actor who must invoke this listener. Resolved from `props.assignment.assignedActor.did`. */
-    assigneeDid: string;
-    /** ISO timestamp when the source emission happened. */
-    emittedAt: string;
-    /** ISO timestamp after which this pending invocation is considered expired. Resolved from `FlowCapability.ttl` at queue time. */
-    expiresAt: string;
+declare function validateActionProof(action: Pick<ActionDefinition, 'type' | 'sideEffect'> & {
+    proof?: ActionProofDeclaration;
+}, output: Record<string, unknown>): ProofValidationResult;
+
+type CompletionVerificationStatus = 'verified' | 'unverified' | 'not_completed';
+interface CompletionVerification {
+    status: CompletionVerificationStatus;
+    /** Populated when status is 'unverified'. */
+    reason?: string;
 }
-/**
- * Compute a deterministic id for a pending invocation from its content.
- *
- * The same (sourceBlockId, sourceRunId, listenerBlockId, eventName,
- * eventIndex) tuple always produces the same id. This is the property that
- * makes the reconciliation loop idempotent — re-running it from a different
- * client, or after a page refresh, produces the same `Y.Map.set` operation
- * with the same key, which Yjs converges to a single entry.
- *
- * Implementation: simple deterministic string concatenation, hashed via a
- * 32-bit FNV-1a. The id is short and stable; collision risk within a single
- * flow is negligible because the inputs are scoped (block ids are unique
- * within a flow, run ids are unique within a block).
- */
-declare function computePendingInvocationId(args: {
-    sourceBlockId: string;
-    sourceRunId: string;
-    listenerBlockId: string;
-    eventName: string;
-    eventIndex: number;
-}): string;
-/**
- * Walk an inputs object and collect every RuntimeRef of the form
- * `nodeId.output.fieldPath`. Returns a map of `{refString: resolvedValue}`
- * suitable for storing as `PendingInvocation.refSnapshots`.
- *
- * The walker mirrors `resolveRuntimeRefs` in `flowCompiler/resolveRefs.ts`
- * but reads instead of resolving — it captures the current value of each
- * ref so the listener can later resolve against the snapshot rather than
- * against current state.
- *
- * See `docs/events-and-triggers-plan.md` §3.5.1.
- */
-declare function snapshotInputRefs(inputs: unknown, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined): Record<string, unknown>;
-/**
- * Get the top-level pending invocations Y.Map from the editor's yDoc.
- * Lazily creates it if missing.
- *
- * Shape: `Y.Map<blockId, Y.Map<pendingInvocationId, PendingInvocation>>`.
- * The outer map is keyed by listener block id; the inner map is keyed by
- * deterministic pending invocation id (see `computePendingInvocationId`).
- */
-declare function getPendingInvocationsMap(yDoc: Y.Doc): Y.Map<Y.Map<unknown>>;
-/**
- * Get the inner pending-invocations map for a specific listener block.
- * Lazily creates it if missing. Caller is responsible for being inside a
- * Yjs transaction if atomic creation matters.
- */
-declare function getOrCreateBlockPendingMap(yDoc: Y.Doc, blockId: string): Y.Map<unknown>;
-/**
- * Read all pending invocations for a block as plain JS objects.
- * Returns an array sorted by `emittedAt` ascending (oldest first).
- */
-declare function readPendingInvocations(yDoc: Y.Doc, blockId: string): PendingInvocation[];
-/**
- * Idempotently write a pending invocation under its deterministic id.
- *
- * Returns true if a new entry was created, false if the id already
- * existed (meaning another client or a previous reconciliation pass
- * already queued this invocation). This is the property that makes
- * `reconcilePendingInvocations` safe to run from multiple clients
- * simultaneously and across page refreshes — see plan §18.
- *
- * Wraps the write in a Yjs transaction so the existence check and the
- * subsequent set are atomic from the local client's perspective. Concurrent
- * clients each computing the same id will all converge to a single entry
- * because Y.Map.set with the same key is last-writer-wins on identical
- * content.
- */
-declare function queuePendingInvocation(yDoc: Y.Doc, listenerBlockId: string, invocation: PendingInvocation): boolean;
-/**
- * Remove a pending invocation by id. Used when the assignee completes the
- * invocation (transitioning to a `block.run` audit trail entry) or when
- * the expiration sweep marks it as expired.
- */
-declare function removePendingInvocation(yDoc: Y.Doc, listenerBlockId: string, pendingInvocationId: string): boolean;
-/**
- * Append a run record to the audit trail for a block. Run records are
- * stored as audit trail events with `type: 'block.run'` and the structured
- * data in `details`. Per Phase 0 #2 of eng review pass 2, this avoids
- * inventing a parallel `_yRunHistory` storage system.
- *
- * Y.Array.push from concurrent clients merges correctly — verified by the
- * existing `useAuditTrail` shipping in production.
- */
-declare function appendRunRecord(yDoc: Y.Doc, blockId: string, details: RunRecordDetails, userId: string): void;
-/**
- * Read all run records for a block from the audit trail. Filters audit
- * trail entries to only those with `type: 'block.run'`.
- */
-declare function readRunRecords(yDoc: Y.Doc, blockId: string): RunRecordDetails[];
-/**
- * A failed listener run, attributed to the source block emission that
- * triggered it. Used by the failure visibility surface (CP-1) on source
- * blocks: the source block can show "N listeners failed for your last run".
- */
-interface FailedListenerRun {
-    /** Block id of the listener whose run failed. */
-    listenerBlockId: string;
-    /** The full RunRecordDetails of the failed listener invocation. */
-    record: RunRecordDetails;
+interface VerifyCompletionParams {
+    runtime: FlowNodeRuntimeState | undefined | null;
+    blockId: string;
+    /** Action type of the block, used to re-check the proof declaration. */
+    actionType?: string;
+    /** Invocation lookup, typically backed by the doc's `invocations` Y.Map. */
+    getInvocation?: (cid: string) => StoredInvocation | undefined | null;
+    /** Flow schema version; UCAN binding is only required when the version policy demands it. */
+    schemaVersion?: string;
 }
 /**
- * Find all failed listener runs that were triggered by a specific source
- * block run. Walks every block's audit trail, filters to listener runs
- * triggered by (sourceBlockId, sourceRunId), and returns the ones with an
- * error set.
- *
- * Used by the source block UI to show a failure badge linked to a specific
- * run — if Sally evaluates 10 claims and 2 of Mike's emails fail, Sally
- * sees "2 failed listeners on claim-G" rather than discovering it days
- * later in the email service logs.
- */
-declare function findFailedListenersForSourceRun(yDoc: Y.Doc, sourceBlockId: string, sourceRunId: string, listenerBlockIds: string[]): FailedListenerRun[];
-/**
- * Replay a previously failed listener run by re-queueing a pending
- * invocation with the same content. Reuses the original frozen payload
- * and ref snapshots from the failed run record's audit trail entry, so the
- * replay sees exactly the same data the original invocation saw.
- *
- * CP-2 from the plan. Used by the replay button in the failure visibility
- * surface. Returns true if a new pending invocation was queued.
- *
- * Note: replay does NOT re-derive the deterministic id from the original
- * source emission, because the original pending invocation's id is already
- * present (or removed) in the pendingInvocations Y.Map. Instead, replay
- * generates a fresh id by appending a `:replay-N` suffix to the original.
- * This means the replay creates a NEW pending invocation that the assignee
- * can act on, separate from any history of the original.
- */
-declare function replayFailedListenerRun(yDoc: Y.Doc, failedRecord: RunRecordDetails, listenerBlockId: string, originalPayload: Record<string, unknown>, originalRefSnapshots: Record<string, unknown>, assigneeDid: string): boolean;
+ * Decide whether a block's `state: 'completed'` can be trusted.
+ *
+ * Anyone with room write access can set `completed` directly in the runtime
+ * Y.Map — a completion is only *verified* when it carries the evidence the
+ * execution kernel writes:
+ *
+ * 1. Proof of execution per the action's `proof` declaration (all versions).
+ * 2. On UCAN-enforced flows (policy.ucanRequired), a `lastInvocationCid`
+ *    that resolves in the invocation store to a successful invocation for
+ *    this block.
+ *
+ * The invocation check is store-level PRESENCE, not a cryptographic
+ * re-verification of the CAR bytes: signatures are validated when the
+ * invocation is minted, but the `invocations` Y.Map is room-writable, so a
+ * member with write access can forge a matching `{ result: 'success', blockId }`
+ * entry and pass this check. This raises the bar (a completion must at least
+ * reference a resolvable, successful, block-matching invocation) but does NOT
+ * make completions unforgeable — that needs read-time CAR-signature
+ * re-verification against the delegation chain (open trust-model decision, H3).
+ * Do not describe a completion that passes here as "impossible to forge".
+ *
+ * Consumers gate on this instead of raw `state === 'completed'`:
+ * trigger reconciliation (event sources), flow-agent planning (Done
+ * classification), and the FlowView completion badge.
+ */
+declare function verifyCompletion(params: VerifyCompletionParams): CompletionVerification;
+declare function isVerifiedCompletion(params: VerifyCompletionParams): boolean;
 
 declare function reconcilePendingInvocations(editor: IxoEditorType): void;
 declare function getActionForBlock(block: any): ReturnType<typeof getAction>;
@@ -371,6 +233,62 @@ declare function writeRunRecordAndReconcile(editor: IxoEditorType, blockId: stri
     sourceRunId?: string;
 }): void;
 
+/**
+ * Flow Version Manifest
+ *
+ * Single source of truth for what each schema version requires.
+ * Blocks and components read policy hints rather than checking version strings directly.
+ */
+type FlowVersionString = '0.3' | '1.0.0';
+interface VersionPolicyUi {
+    /** Show the delegation management panel in block config */
+    showDelegationPanel: boolean;
+    /** Show the whitelist (specific actors) option in authorization config */
+    showWhitelistConfig: boolean;
+    /** Show the "anyone with flow access" option in authorization config */
+    showAnyoneConfig: boolean;
+    /** Show a banner when a newer version is available */
+    showMigrationBanner: boolean;
+    /** Require PIN entry for block execution (invocation signing) */
+    requirePinForExecution: boolean;
+}
+interface VersionPolicy {
+    /** Semver-style version identifier */
+    version: FlowVersionString;
+    /** Human-readable label */
+    label: string;
+    /** Whether UCAN delegation chains are required for all executions */
+    ucanRequired: boolean;
+    /** Whether a root delegation must exist before any execution */
+    delegationRootRequired: boolean;
+    /** Whether whitelist-only authorization (no parentCapability) is acceptable */
+    whitelistOnlyAllowed: boolean;
+    /** Whether unrestricted access (no authorisedActors, no parentCapability) is acceptable */
+    unrestrictedAllowed: boolean;
+    /** Which execution path to use */
+    executionPath: 'legacy' | 'invocation';
+    /** Which authorization function to use */
+    authorizationFn: 'v1' | 'v2';
+    /** Allowed authorization modes in the UI */
+    allowedAuthModes: Array<'anyone' | 'actors' | 'capability'>;
+    /** UI rendering hints — blocks query these instead of checking version strings */
+    ui: VersionPolicyUi;
+    /** Human-readable description of this version */
+    description: string;
+}
+declare const VERSION_MANIFEST: Record<FlowVersionString, VersionPolicy>;
+/** The version stamped on newly created flows */
+declare const LATEST_VERSION: FlowVersionString;
+/**
+ * Get the policy for a given schema version.
+ * Unknown versions fall back to the strictest (latest) policy.
+ */
+declare function getVersionPolicy(version: string): VersionPolicy;
+/**
+ * Check whether `current` is at least `minimum` in the migration path.
+ */
+declare function isVersionAtLeast(current: string, minimum: FlowVersionString): boolean;
+
 /**
  * Writes compiled blocks into BlockNote's collaborative XmlFragment using the
  * ProseMirror/Yjs structure that BlockNote reads from collaboration.
@@ -572,7 +490,7 @@ interface ExecuteFlowAgentCoreCommandOptions {
     actorType: 'entity' | 'user';
     entityRoomId?: string;
     actionServices?: ActionServices;
-    actionHandlers?: unknown;
+    actionHandlers?: ActionHandlers;
     delegationStore?: UcanDelegationStore;
     delegations?: StoredDelegation[];
     invocationStore?: InvocationStore;
@@ -593,10 +511,25 @@ interface ClassifyNodeStateInput {
     runtime: FlowNodeRuntimeState;
     now: number;
     pendingInvocationCount?: number;
+    /**
+     * Verification of a `completed` runtime entry (see
+     * `flowEngine/verifiedCompletion.ts`). When provided and 'unverified', the
+     * node classifies as Blocked instead of Done — the planner must not advance
+     * past a completion that lacks proof or a valid invocation. Omitted ⇒
+     * legacy behavior (completed = Done).
+     */
+    completionVerification?: CompletionVerification;
+    /**
+     * Whether this block's action is a repeatable ('many') capability. A
+     * repeatable block that has fired (`completed`) is classified 'Active', not
+     * 'Done' — it is a standing capability, never a finished task. See
+     * `ActionDefinition.cardinality`.
+     */
+    isRepeatable?: boolean;
 }
 declare function classifyBlockerCause(block: unknown, runtime: FlowNodeRuntimeState): FlowAgentBlockerCause | undefined;
-declare function classifyNodeState({ block, runtime, now, pendingInvocationCount }: ClassifyNodeStateInput): FlowAgentPublicNodeState;
-declare function snapshotNode(block: unknown, runtime: FlowNodeRuntimeState, now: number, pendingInvocationCount?: number): FlowAgentNodeSnapshot;
+declare function classifyNodeState({ block, runtime, now, pendingInvocationCount, completionVerification, isRepeatable, }: ClassifyNodeStateInput): FlowAgentPublicNodeState;
+declare function snapshotNode(block: unknown, runtime: FlowNodeRuntimeState, now: number, pendingInvocationCount?: number, completionVerification?: CompletionVerification, isRepeatable?: boolean): FlowAgentNodeSnapshot;
 
 /**
  * Compute an IPFS-compatible CID for arbitrary content.
@@ -725,4 +658,4 @@ declare function createOracleInitFlowTemplate(): {
     nodes: FlowNode[];
 };
 
-export { ActionDefinition, ActionServices, type AddFlowNodeOptions, type BlockConditionInput, type ClassifyNodeStateInput, CompiledBlock, CompiledEdge, CompiledFlow, type EvaluatorOperator, type ExecuteFlowAgentCoreCommandOptions, type ExecuteQueuedFlowAgentCoreCommandsOptions, type FailedListenerRun, FlowAgentBlockerCause, FlowAgentCommand, FlowAgentCommandResult, FlowAgentContext, FlowAgentExecutor, FlowAgentNodeSnapshot, FlowAgentPublicNodeState, type FlowDocumentNode, type FlowDocumentRead, FlowNode, FlowNodeRuntimeState, InvocationStore, OutputSchemaField, type PendingInvocation, RUN_RECORD_AUDIT_TYPE, type RunRecordDetails, STEP_COMPLETED_EVENT, STEP_COMPLETED_EVENT_NAME, StoredDelegation, type TriggerResolutionContext, UcanDelegationStore, UcanService, addFlowNode, appendRunRecord, buildBlockConditionsProp, buildServicesFromHandlers, canToType, classifyBlockerCause, classifyNodeState, computeCID, computeJsonCID, computePendingInvocationId, createOracleInitFlowTemplate, executeFlowAgentCoreCommand, executeQueuedFlowAgentCoreCommands, findFailedListenersForSourceRun, getAction, getActionByCan, getActionForBlock, getAllActions, getAllCanMappings, getEventsForBlock, getOrCreateBlockPendingMap, getOutputSchemaForBlock, getPendingInvocationsMap, hasAction, oracleInitSurveySchema, queuePendingInvocation, readBlocksFromFragment, readFlowDocument, readPendingInvocations, readRunRecords, reconcilePendingInvocations, registerAction, removeBlockFromFragment, removeFlowNode, removePendingInvocation, reorderFlowNodes, replaceBlockInFragment, replayFailedListenerRun, resetStepRuntime, resolveRuntimeRefs, setBlockProps, setFormAnswers, snapshotInputRefs, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, writeCompiledBlocksToFragment, writeRunRecordAndReconcile };
+export { ActionDefinition, ActionHandlers, type ActionManifest, type ActionManifestEntry, ActionServices, type AddFlowNodeOptions, type BlockConditionInput, type ClassifyNodeStateInput, CompiledBlock, CompiledEdge, CompiledFlow, type CompletionVerification, type CompletionVerificationStatus, type EvaluatorOperator, type ExecuteFlowAgentCoreCommandOptions, type ExecuteQueuedFlowAgentCoreCommandsOptions, FlowAgentBlockerCause, FlowAgentCommand, FlowAgentCommandResult, FlowAgentContext, FlowAgentExecutor, FlowAgentNodeSnapshot, FlowAgentPublicNodeState, type FlowDocumentNode, type FlowDocumentRead, FlowNode, FlowNodeRuntimeState, type FlowVersionString, InvocationStore, LATEST_VERSION, type ManifestProofDeclaration, OutputSchemaField, PROOF_MISSING_CODE, type ProofValidationResult, RunRecordDetails, STEP_COMPLETED_EVENT, STEP_COMPLETED_EVENT_NAME, StoredDelegation, StoredInvocation, type TriggerResolutionContext, UcanDelegationStore, UcanService, VERSION_MANIFEST, type VersionPolicy, addFlowNode, buildBlockConditionsProp, buildServicesFromHandlers, canToType, classifyBlockerCause, classifyNodeState, computeCID, computeJsonCID, createOracleInitFlowTemplate, executeFlowAgentCoreCommand, executeQueuedFlowAgentCoreCommands, generateActionManifest, getAction, getActionByCan, getActionForBlock, getAliasEntries, getAllActions, getAllCanMappings, getEventsForBlock, getOutputSchemaForBlock, getVersionPolicy, hasAction, isVerifiedCompletion, isVersionAtLeast, oracleInitSurveySchema, readBlocksFromFragment, readFlowDocument, reconcilePendingInvocations, registerAction, removeBlockFromFragment, removeFlowNode, reorderFlowNodes, replaceBlockInFragment, resetStepRuntime, resolveRuntimeRefs, setBlockProps, setFormAnswers, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, validateActionProof, verifyCompletion, writeCompiledBlocksToFragment, writeRunRecordAndReconcile };

package/dist/core/index.js

@@ -8,12 +8,15 @@ import {
   setFormAnswers,
   swapFlowBlocks,
   updateNodeRuntime
-} from "../chunk-OFW7NYJK.js";
+} from "../chunk-EOMC6ZVX.js";
 import {
   FlowAgentService,
+  LATEST_VERSION,
+  PROOF_MISSING_CODE,
   RUN_RECORD_AUDIT_TYPE,
   STEP_COMPLETED_EVENT,
   STEP_COMPLETED_EVENT_NAME,
+  VERSION_MANIFEST,
   acquireFlowAgentLease,
   appendAgentLedgerEvent,
   appendRunRecord,
@@ -45,10 +48,12 @@ import {
   executeQueuedAgentCommands,
   executeQueuedFlowAgentCoreCommands,
   findFailedListenersForSourceRun,
+  generateActionManifest,
   getAction,
   getActionByCan,
   getActionForBlock,
   getActiveEditor,
+  getAliasEntries,
   getAllActions,
   getAllCanMappings,
   getEventsForBlock,
@@ -56,11 +61,14 @@ import {
   getOrCreateBlockPendingMap,
   getOutputSchemaForBlock,
   getPendingInvocationsMap,
+  getVersionPolicy,
   hasAction,
   isAuthorized,
   isCapabilityMatch,
   isExternalMutation,
   isRuntimeRef,
+  isVerifiedCompletion,
+  isVersionAtLeast,
   mergeCompiledFlows,
   planRalphLoopCommands,
   queueAgentCommand,
@@ -92,11 +100,13 @@ import {
   toEvaluatorOperator,
   typeToCan,
   updateAgentCommand,
+  validateActionProof,
   validateAgentCommand,
   validateFlowAgentLease,
+  verifyCompletion,
   writeCompiledBlocksToFragment,
   writeRunRecordAndReconcile
-} from "../chunk-KNMPGX5G.js";
+} from "../chunk-5TJK6JKV.js";
 import {
   computeCID,
   computeJsonCID
@@ -483,9 +493,12 @@ function createOracleInitFlowTemplate() {
 }
 export {
   FlowAgentService,
+  LATEST_VERSION,
+  PROOF_MISSING_CODE,
   RUN_RECORD_AUDIT_TYPE,
   STEP_COMPLETED_EVENT,
   STEP_COMPLETED_EVENT_NAME,
+  VERSION_MANIFEST,
   acquireFlowAgentLease,
   addFlowNode,
   appendAgentLedgerEvent,
@@ -521,10 +534,12 @@ export {
   executeQueuedAgentCommands,
   executeQueuedFlowAgentCoreCommands,
   findFailedListenersForSourceRun,
+  generateActionManifest,
   getAction,
   getActionByCan,
   getActionForBlock,
   getActiveEditor,
+  getAliasEntries,
   getAllActions,
   getAllCanMappings,
   getEventsForBlock,
@@ -532,11 +547,14 @@ export {
   getOrCreateBlockPendingMap,
   getOutputSchemaForBlock,
   getPendingInvocationsMap,
+  getVersionPolicy,
   hasAction,
   isAuthorized,
   isCapabilityMatch,
   isExternalMutation,
   isRuntimeRef,
+  isVerifiedCompletion,
+  isVersionAtLeast,
   mergeCompiledFlows,
   oracleInitSurveySchema,
   planRalphLoopCommands,
@@ -577,8 +595,10 @@ export {
   typeToCan,
   updateAgentCommand,
   updateNodeRuntime,
+  validateActionProof,
   validateAgentCommand,
   validateFlowAgentLease,
+  verifyCompletion,
   writeCompiledBlocksToFragment,
   writeRunRecordAndReconcile
 };