@ixo/editor 6.31.0 → 6.31.1

package/dist/{chunk-ZXNBOVAA.js → chunk-TBCPHCFA.js}

@@ -499,6 +499,398 @@ async function sendDirectMessage(matrixClient, targetDid, message) {
   return { roomId };
 }
 
+// src/core/lib/actionRegistry/digest.ts
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function canonicalActionJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Action manifest cannot contain non-finite numbers");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : canonicalActionJson(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const fields = Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => compareCodeUnits(a, b));
+    return `{${fields.map(([key, item]) => `${JSON.stringify(key)}:${canonicalActionJson(item)}`).join(",")}}`;
+  }
+  throw new Error(`Action manifest cannot contain ${typeof value}`);
+}
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(text) {
+  const input = new TextEncoder().encode(text);
+  const bitLength = input.length * 8;
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(input);
+  bytes[input.length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4, false);
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + sum1 + choice + SHA256_K[index] + words[index] >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sha256Digest(value) {
+  return `sha256:${sha256Hex(canonicalActionJson(value))}`;
+}
+
+// src/core/lib/actionRegistry/topicSemanticRecords.ts
+import Ajv2020 from "ajv/dist/2020.js";
+var stringArray = { type: "array", items: { type: "string" } };
+var digest = { type: "string", pattern: "^sha256:[a-f0-9]{64}$" };
+var dateTime = {
+  type: "string",
+  pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"
+};
+var MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT = 25;
+var MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES = 32 * 1024;
+function closed(required, properties) {
+  return { type: "object", required, additionalProperties: false, properties };
+}
+var TOPIC_SEMANTIC_RECORD_DEFINITIONS = [
+  {
+    type: "org.ixo.topic.claim-submission",
+    version: 1,
+    displayName: "Claim submitted",
+    description: "Records that a claim was submitted to a collection.",
+    valueSchema: closed(["claimId", "collectionId", "deedDid", "submittedByDid", "submittedAt", "transactionHash", "submissionDigest"], {
+      claimId: { type: "string" },
+      collectionId: { type: "string" },
+      deedDid: { type: "string" },
+      submittedByDid: { type: "string" },
+      submittedAt: dateTime,
+      transactionHash: { type: "string" },
+      submissionDigest: digest
+    })
+  },
+  {
+    type: "org.ixo.topic.claim-evaluation",
+    version: 1,
+    displayName: "Claim evaluated",
+    description: "Records the governed evaluation outcome for a claim.",
+    valueSchema: closed(["claimId", "collectionId", "deedDid", "decision", "evaluatedByDid", "evaluatedAt", "transactionHash", "evidenceDigest"], {
+      claimId: { type: "string" },
+      collectionId: { type: "string" },
+      deedDid: { type: "string" },
+      decision: { type: "string" },
+      evaluatedByDid: { type: "string" },
+      evaluatedAt: dateTime,
+      verificationProof: { type: "string" },
+      transactionHash: { type: "string" },
+      evidenceDigest: digest
+    })
+  },
+  {
+    type: "org.ixo.topic.proposal-receipt",
+    version: 1,
+    displayName: "Governance proposal update",
+    description: "Records the creation of, or a vote on, a governance proposal.",
+    valueSchema: closed(["event", "proposalId", "proposalContractAddress"], {
+      event: { type: "string", enum: ["created", "vote-cast"] },
+      actionType: { type: "string" },
+      proposalId: { type: "string" },
+      proposalContractAddress: { type: "string" },
+      coreAddress: { type: "string" },
+      title: { type: "string" },
+      proposalTitle: { type: "string" },
+      descriptionDigest: digest,
+      proposalDescriptionDigest: digest,
+      status: { type: "string" },
+      vote: { type: "string" },
+      rationaleDigest: digest,
+      actorDid: { type: "string" },
+      votedAt: dateTime,
+      createdAt: dateTime
+    })
+  },
+  {
+    type: "org.ixo.topic.work-event",
+    version: 1,
+    displayName: "Work update",
+    description: "Records an assignment, dispatch, checkpoint, submission, or acceptance of work.",
+    valueSchema: closed(["workId", "resourceType", "phase", "assigneeDid", "note", "artifactReferences", "evidenceReferences", "actorDid", "occurredAt"], {
+      workId: { type: "string" },
+      resourceType: { type: "string" },
+      phase: { type: "string", enum: ["requested", "dispatched", "in_progress", "ready_for_review", "completed"] },
+      assigneeDid: { type: "string" },
+      note: { type: "string" },
+      artifactReferences: stringArray,
+      evidenceReferences: stringArray,
+      actorDid: { type: "string" },
+      occurredAt: dateTime
+    })
+  },
+  {
+    type: "org.ixo.topic.agent-result",
+    version: 1,
+    displayName: "Agent result",
+    description: "Records a delegated agent result and its evidence references without exposing invocation inputs.",
+    valueSchema: closed(["sessionId", "result", "resultDigest", "evidenceReferences", "evidenceDigest", "providerReceiptReference"], {
+      sessionId: { type: "string" },
+      result: { description: "Provider-owned result extension point." },
+      resultDigest: digest,
+      evidenceReferences: stringArray,
+      evidenceDigest: digest,
+      providerReceiptReference: { type: "string" }
+    })
+  },
+  {
+    type: "org.ixo.topic.agent-cancellation",
+    version: 1,
+    displayName: "Agent cancelled",
+    description: "Records cancellation of a delegated agent session.",
+    valueSchema: closed(["sessionId", "status", "providerReceiptReference"], {
+      sessionId: { type: "string" },
+      status: { const: "cancelled" },
+      providerReceiptReference: { type: "string" }
+    })
+  },
+  {
+    type: "org.ixo.topic.evidence",
+    version: 1,
+    displayName: "Evidence collected",
+    description: "Records collected evidence, provenance, and stable evidence references.",
+    valueSchema: closed(["question", "evidence", "provenance", "evidenceReferences", "evidenceDigest"], {
+      question: { type: "string" },
+      evidence: { description: "Provider-owned evidence extension point." },
+      provenance: { description: "Provider-owned provenance extension point." },
+      evidenceReferences: stringArray,
+      evidenceDigest: digest
+    })
+  },
+  ...["proposed", "accepted"].map(
+    (status) => ({
+      type: `org.ixo.topic.${status}-answer`,
+      version: 1,
+      displayName: status === "accepted" ? "Answer accepted" : "Answer proposed",
+      description: status === "accepted" ? "Records an answer accepted by the stated authority." : "Records an answer proposed for review.",
+      valueSchema: closed(["answer", "status", "proposedAnswerRecordId", "authorityDid", "evidenceReferences", "limitations", "occurredAt"], {
+        answer: { type: "string" },
+        status: { const: status },
+        proposedAnswerRecordId: { type: "string" },
+        authorityDid: { type: "string" },
+        evidenceReferences: stringArray,
+        limitations: { type: "string" },
+        occurredAt: dateTime
+      })
+    })
+  ),
+  ...["assertion", "review"].map(
+    (kind) => ({
+      type: `org.ixo.topic.evaluation-${kind}`,
+      version: 1,
+      displayName: kind === "review" ? "Evaluation reviewed" : "Evaluation assertion",
+      description: kind === "review" ? "Records a signed human review of an evaluation assertion." : "Records a signed evaluation assertion.",
+      valueSchema: closed(
+        [kind === "review" ? "reviewId" : "assertionId", "providerResult", "methodologyRevision", "rubricRevision", "evaluatorDid", "evidenceReferences", "signature"],
+        {
+          assertionId: { type: "string" },
+          reviewId: { type: "string" },
+          providerResult: { type: "object", description: "Provider-owned evaluation result extension point.", additionalProperties: true },
+          methodologyRevision: { type: "string" },
+          rubricRevision: { type: "string" },
+          evaluatorDid: { type: "string" },
+          evidenceReferences: stringArray,
+          signature: { type: "string" }
+        }
+      )
+    })
+  ),
+  {
+    type: "org.ixo.topic.settlement-record",
+    version: 1,
+    displayName: "Settlement update",
+    description: "Records the provider reference and terminal status of an approved settlement execution.",
+    valueSchema: closed(["settlementId", "transactionReference", "providerReceiptReference", "status"], {
+      settlementId: { type: "string" },
+      transactionReference: { type: "string" },
+      providerReceiptReference: { type: "string" },
+      status: { type: "string", enum: ["submitted", "confirmed", "needs_verification"] }
+    })
+  },
+  {
+    type: "org.ixo.topic.incident-escalation",
+    version: 1,
+    displayName: "Incident escalated",
+    description: "Records that an incident was escalated to the stated recipients.",
+    valueSchema: closed(["severity", "affectedResources", "recipients", "evidenceReferences", "summary", "escalationId", "notifiedAt", "providerReceiptReferences"], {
+      severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      affectedResources: stringArray,
+      recipients: stringArray,
+      evidenceReferences: stringArray,
+      summary: { type: "string" },
+      escalationId: { type: "string" },
+      notifiedAt: dateTime,
+      providerReceiptReferences: stringArray
+    })
+  },
+  {
+    type: "org.ixo.topic.incident-mitigation",
+    version: 1,
+    displayName: "Incident mitigation recorded",
+    description: "Records mitigation work for an incident without changing the incident lifecycle.",
+    valueSchema: closed(["mitigation", "affectedResources", "evidenceReferences", "recordedBy", "occurredAt"], {
+      mitigation: { type: "string" },
+      affectedResources: stringArray,
+      evidenceReferences: stringArray,
+      recordedBy: { type: "string" },
+      occurredAt: dateTime
+    })
+  }
+];
+var definitionsByType = new Map(TOPIC_SEMANTIC_RECORD_DEFINITIONS.map((definition) => [definition.type, definition]));
+var ajv = new Ajv2020({ allErrors: true, strict: false });
+var validators = /* @__PURE__ */ new Map();
+function getTopicSemanticRecordDefinitions(types) {
+  return types.map((type) => definitionsByType.get(type)).filter((definition) => !!definition);
+}
+function validateTopicSemanticRecord(record, topic) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  const candidate = record;
+  const envelopeKeys = /* @__PURE__ */ new Set(["type", "id", "version", "value", "evidenceReferences"]);
+  if (Object.keys(candidate).some((key) => !envelopeKeys.has(key)) || typeof candidate.type !== "string" || typeof candidate.id !== "string" || !candidate.id || !Number.isInteger(candidate.version) || Number(candidate.version) < 1 || !candidate.value || typeof candidate.value !== "object" || Array.isArray(candidate.value)) {
+    return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  }
+  if (candidate.evidenceReferences !== void 0 && (!Array.isArray(candidate.evidenceReferences) || candidate.evidenceReferences.some((item) => typeof item !== "string"))) {
+    return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  }
+  const definition = topic.semanticRecordTypes.find((item) => item.type === candidate.type);
+  if (!definition) return { valid: false, code: "UNKNOWN_RECORD_TYPE" };
+  if (candidate.version !== definition.version) return { valid: false, code: "UNSUPPORTED_RECORD_VERSION" };
+  const validatorKey = `${definition.type}@${definition.version}:${sha256Digest(definition.valueSchema)}`;
+  let validate = validators.get(validatorKey);
+  if (!validate) {
+    validate = ajv.compile(definition.valueSchema);
+    validators.set(validatorKey, validate);
+  }
+  if (!validate(candidate.value)) return { valid: false, code: "INVALID_RECORD_VALUE", errors: validate.errors || void 0 };
+  return { valid: true, definition };
+}
+function validateTopicSemanticRecordBatch(records, topic) {
+  if (records.length > MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT) return { valid: false, code: "TOO_MANY_RECORDS" };
+  for (const record of records) {
+    const validation = validateTopicSemanticRecord(record, topic);
+    if (!validation.valid) return validation;
+  }
+  try {
+    const byteLength = new TextEncoder().encode(canonicalActionJson(records)).byteLength;
+    if (byteLength > MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES) return { valid: false, code: "RECORD_BATCH_TOO_LARGE" };
+  } catch {
+    return { valid: false, code: "INVALID_RECORD_BATCH" };
+  }
+  return { valid: true };
+}
+
 // src/core/lib/actionRegistry/canMapping.ts
 var CAN_TO_TYPE = {
   "flow/run.start": "qi/flow.run.start",
@@ -548,10 +940,11 @@ var CAN_TO_TYPE = {
   "outlook.email/send": "qi/outlook.email.send",
   "slack.message/send": "qi/slack.message.send",
   "googlecalendar.event/create": "qi/googlecalendar.event.create",
-  // Calendar integration (self-connected)
-  "calendar.event/create": "qi/calendar.event.create",
-  "calendar.event/update": "qi/calendar.event.update",
-  "calendar.event/list": "qi/calendar.event.list",
+  // Google Calendar, self-connected (renamed from qi/calendar.* — IXO-4420 §5).
+  // The cans keep their historical values so existing UCAN grants still match.
+  "calendar.event/create": "qi/googlecalendar.event.create-self",
+  "calendar.event/update": "qi/googlecalendar.event.update-self",
+  "calendar.event/list": "qi/googlecalendar.event.list-self",
   // Xero integration
   "xero.contact/create": "qi/xero.contact.create",
   "xero.invoice/create": "qi/xero.invoice.create",
@@ -580,6 +973,160 @@ function getAllCanMappings() {
   return Object.entries(CAN_TO_TYPE).map(([can, type]) => ({ can, type }));
 }
 
+// src/core/lib/actionRegistry/presentation.ts
+var PRESENTATION = {
+  oracle: { displayName: "Ask your Agent", description: "Send a prompt to the Personal Agent" },
+  "oracle.prompt": { displayName: "Oracle Prompt", description: "Send a prompt to the Personal Agent" },
+  "qi/bid.evaluate": { displayName: "Evaluate Bid", description: "Approve or reject a bid" },
+  "qi/bid.submit": { displayName: "Bid", description: "Submit a bid application" },
+  "qi/agent.cancel": { displayName: "Cancel Agent", description: "Cancel a delegated agent session" },
+  "qi/agent.invoke": { displayName: "Invoke Agent", description: "Delegate a task to an authorised agent runtime" },
+  "qi/answer.accept": { displayName: "Accept Answer", description: "Accept a proposed answer using the stated authority" },
+  "qi/answer.propose": { displayName: "Propose Answer", description: "Propose an answer for review in the Topic" },
+  "qi/blueprint.artifact-preview": { displayName: "Preview Blueprint Artifact", description: "Preview an authored Blueprint artifact before saving it" },
+  "qi/blueprint.artifact-save": { displayName: "Save Blueprint Artifact", description: "Save an authored artifact to the Blueprint workspace" },
+  "qi/blueprint.checklist-update": { displayName: "Update Blueprint Checklist", description: "Record progress against the Blueprint authoring checklist" },
+  "qi/blueprint.guided-authoring": { displayName: "Guide Blueprint Authoring", description: "Generate guided authoring input for the current Blueprint phase" },
+  "qi/blueprint.journey-resume": { displayName: "Resume Blueprint Journey", description: "Resume an existing Blueprint authoring journey" },
+  "qi/blueprint.phase-confirm": { displayName: "Confirm Blueprint Phase", description: "Confirm completion of the current Blueprint authoring phase" },
+  "qi/blueprint.publish": { displayName: "Publish Blueprint", description: "Publish an approved Blueprint release" },
+  "qi/blueprint.release-compile": { displayName: "Compile Blueprint Release", description: "Compile Blueprint artifacts into a release candidate" },
+  "qi/blueprint.review-respond": { displayName: "Respond to Blueprint Review", description: "Respond to review feedback on a Blueprint release" },
+  "qi/blueprint.review-submit": { displayName: "Submit Blueprint Review", description: "Submit a Blueprint release for review" },
+  "qi/blueprint.reviewer-assign": { displayName: "Assign Blueprint Reviewer", description: "Assign a reviewer to a Blueprint release" },
+  "qi/blueprint.workspace-start": { displayName: "Start Blueprint Workspace", description: "Create a workspace for a new Blueprint authoring journey" },
+  "qi/calendar.event.create": { displayName: "Create Calendar event", description: "Create an event on a connected Calendar" },
+  "qi/calendar.event.list": { displayName: "List Calendar events", description: "Fetch events from a connected Calendar" },
+  "qi/calendar.event.update": { displayName: "Update Calendar event", description: "Replace an existing Calendar event" },
+  "qi/carbon.harvest": { displayName: "Harvest Carbon", description: "Claim carbon credits into your wallet" },
+  "qi/carbon.loadBatches": { displayName: "Load Carbon Batches", description: "Reconcile harvestable and retireable CARBON credits" },
+  "qi/carbon.retire": { displayName: "Retire Carbon", description: "Permanently retire carbon credits to offset impact" },
+  "qi/claim.evaluate": { displayName: "Evaluate Claim", description: "Approve or reject a claim" },
+  "qi/claim.submit": { displayName: "Claim", description: "Submit a claim" },
+  "qi/collection.lifecycle": { displayName: "Claim Collection", description: "Create and manage a claim collection lifecycle" },
+  "qi/collection.create": { displayName: "Create Claim Collection", description: "Pin a protocol release and create its exact on-chain collection record" },
+  "qi/collection.users": { displayName: "Collection Users", description: "Add, list and revoke claim collection contributors & evaluators" },
+  "qi/credential.store": { displayName: "Store Credential", description: "Store a verifiable credential in Matrix room state" },
+  "qi/domain.card-preview": { displayName: "Preview Domain Card", description: "Review an oracle-enriched domain card and approve it before signing" },
+  "qi/domain.sign": { displayName: "Sign Domain", description: "Sign the domain card credential and create the entity on-chain" },
+  "qi/email.send": { displayName: "Email", description: "Send an email to a user" },
+  "qi/eval.connect": { displayName: "Connect Evaluation Service", description: "Authorize one evaluation service for one existing claim collection" },
+  "qi/eval.engine": { displayName: "Evaluation Engine", description: "Enroll a collection and publish its claim-approval rules in one step" },
+  "qi/evaluation.review": { displayName: "Review Evaluation", description: "Review and sign an evaluation assertion" },
+  "qi/evaluation.run": { displayName: "Run Evaluation", description: "Run an evaluation against the selected methodology and rubric" },
+  "qi/evidence.collect": { displayName: "Collect Evidence", description: "Collect evidence and provenance from approved sources" },
+  "qi/flow.run.close": { displayName: "Close Flow Run", description: "Close the current Flow run with a terminal outcome" },
+  "qi/flow.run.start": { displayName: "Start Flow Run", description: "Start a new governed Flow run" },
+  "qi/entity.createOracle": { displayName: "Create Oracle Entity", description: "Create the oracle entity on-chain" },
+  "qi/entity.transfer": { displayName: "Transfer Entity", description: "Transfer ownership of an entity to a new owner" },
+  "qi/form.submit": { displayName: "Form Submit", description: "Submit a form response" },
+  "qi/gmail.email.send": { displayName: "Send Gmail email", description: "Send an email from the template author's Gmail account" },
+  "qi/googlecalendar.event.create": { displayName: "Create Calendar event (delegated)", description: "Create an event on the template author's Google Calendar" },
+  "qi/googlecalendar.event.create-self": { displayName: "Create Calendar event", description: "Create an event on a connected Calendar" },
+  "qi/googlecalendar.event.list-self": { displayName: "List Calendar events", description: "Fetch events from a connected Calendar" },
+  "qi/googlecalendar.event.update-self": { displayName: "Update Calendar event", description: "Replace an existing Calendar event" },
+  "qi/governance.authz.exec": { displayName: "Execute Authorized Action", description: "Propose executing a message the POD was authorized to run" },
+  "qi/governance.authz.grant": { displayName: "Grant Authorization", description: "Propose granting an address authorization to act for the POD" },
+  "qi/governance.authz.revoke": { displayName: "Revoke Authorization", description: "Propose revoking a previously granted authorization" },
+  "qi/governance.chain-governance-vote": { displayName: "Chain Governance Vote", description: "Propose casting the POD's vote on a chain governance proposal" },
+  "qi/governance.contract.execute": { displayName: "Execute Contract", description: "Propose executing a message on a smart contract as the DAO" },
+  "qi/governance.contract.instantiate": { displayName: "Instantiate Contract", description: "Propose instantiating a new smart contract from a code id" },
+  "qi/governance.contract.manage-cw20": { displayName: "Manage Token List", description: "Propose tracking or untracking a cw20 token in the DAO treasury" },
+  "qi/governance.contract.migrate": { displayName: "Migrate Contract", description: "Propose migrating a smart contract the DAO administers to a new code id" },
+  "qi/governance.contract.update-admin": { displayName: "Update Contract Admin", description: "Propose transferring admin rights over a smart contract to a new address" },
+  "qi/governance.custom-message": { displayName: "Custom Message", description: "Propose executing a raw JSON cosmos message (advanced)" },
+  "qi/governance.dao.accept-to-marketplace": { displayName: "Accept to Marketplace", description: "Propose marking an entity as verified on the marketplace" },
+  "qi/governance.dao.admin-exec": { displayName: "DAO Admin Execute", description: "Propose executing admin messages on a SubDAO this POD administers" },
+  "qi/governance.dao.create-entity": { displayName: "Create Entity", description: "Propose broadcasting a raw entity-creation message" },
+  "qi/governance.dao.join": { displayName: "Join Entity", description: "Propose linking this POD as a member of another entity" },
+  "qi/governance.dao.manage-storage": { displayName: "Manage Storage Items", description: "Propose setting or removing an item in the DAO's on-chain storage" },
+  "qi/governance.dao.manage-subdaos": { displayName: "Manage SubDAOs", description: "Propose recognising or removing SubDAOs of this DAO" },
+  "qi/governance.dao.update-info": { displayName: "Update DAO Info", description: "Propose replacing the DAO's name, description and image" },
+  "qi/governance.member-proposal": { displayName: "Membership Proposal", description: "Propose adding/removing members or changing voting power" },
+  "qi/governance.nft.burn": { displayName: "Burn NFT", description: "Propose permanently burning an NFT held by the treasury" },
+  "qi/governance.nft.manage-collections": { displayName: "Manage NFT Collections", description: "Propose tracking or untracking an NFT collection in the treasury" },
+  "qi/governance.nft.transfer": { displayName: "Transfer NFT", description: "Propose transferring an NFT from the treasury" },
+  "qi/governance.settings-proposal": { displayName: "Governance Settings Proposal", description: "Propose new voting rules (period, quorum, thresholds)" },
+  "qi/governance.staking.stake": { displayName: "Stake Treasury Tokens", description: "Propose staking treasury IXO with a validator \u2014 stake, unstake, restake or claim rewards" },
+  "qi/governance.staking.stake-to-group": { displayName: "Stake to POD", description: "Propose staking treasury cw20 tokens into a POD's staking contract" },
+  "qi/governance.submission-config-proposal": { displayName: "Proposal Submission Rules", description: "Propose changing who may submit proposals and the required deposit" },
+  "qi/governance.transaction.mint": { displayName: "Mint Governance Tokens", description: "Propose minting new governance tokens to an address" },
+  "qi/governance.transaction.perform-token-swap": { displayName: "Fund Token Swap", description: "Propose funding the POD\u2019s side of a token swap contract" },
+  "qi/governance.transaction.send-funds": { displayName: "Send Funds", description: "Propose sending funds from the POD treasury" },
+  "qi/governance.transaction.send-group-token": { displayName: "Send POD Tokens", description: "Propose transferring cw20 POD tokens from the treasury" },
+  "qi/governance.transaction.withdraw-token-swap": { displayName: "Withdraw Token Swap", description: "Propose withdrawing the POD\u2019s funds from a token swap contract" },
+  "qi/governance.validator.actions": { displayName: "Validator Actions", description: "Propose a validator operation with the POD's validator account" },
+  "qi/http.request": { displayName: "HTTP Request", description: "Make an HTTP API request" },
+  "qi/http.fetch": { displayName: "Fetch HTTP Resource", description: "Read data from an HTTP endpoint" },
+  "qi/incident.escalate": { displayName: "Escalate Incident", description: "Notify the stated recipients about an incident escalation" },
+  "qi/incident.mitigation.record": { displayName: "Record Incident Mitigation", description: "Record mitigation work and evidence for an incident" },
+  "qi/human.checkbox.set": { displayName: "Checkbox Set", description: "Record a checkbox response" },
+  "qi/human.form.submit": { displayName: "Human Form Submit", description: "Submit a human-completed form" },
+  "qi/identity.create": { displayName: "Create Identity", description: "Create an IID document and Matrix account for a user" },
+  "qi/iid.create": { displayName: "Create IID", description: "Create an IID document on-chain" },
+  "qi/kyc.verify": { displayName: "Identity Verification (KYC)", description: "Verify your identity and save the issued credential to your Vault" },
+  "qi/matrix.dm": { displayName: "Matrix DM", description: "Send a direct message via Matrix" },
+  "qi/matrix.register": { displayName: "Register Matrix Account", description: "Create a Matrix account and access token" },
+  "qi/notification.push": { displayName: "Push Notification", description: "Send a push notification" },
+  "qi/oracle.configureOracle": { displayName: "Configure Oracle", description: "Store oracle secrets and configuration in one step" },
+  "qi/oracle.contract": { displayName: "Create Oracle Contract", description: "Establish the user-oracle Matrix DM room" },
+  "qi/oracle.deploy": { displayName: "Deploy Oracle", description: "Build, deploy, and start the oracle" },
+  "qi/oracle.deploySetup": { displayName: "Set Up Oracle Deployment", description: "Build and prepare the oracle for deployment" },
+  "qi/oracle.deployStart": { displayName: "Start Oracle Deployment", description: "Start the oracle deployment process" },
+  "qi/oracle.invoke": { displayName: "Ask your Agent", description: "Send a prompt to the Personal Agent" },
+  "qi/oracle.storeConfig": { displayName: "Store Oracle Config", description: "Store the oracle configuration in Matrix room state" },
+  "qi/oracle.storeSecrets": { displayName: "Store Oracle Secrets", description: "Store oracle secrets in Matrix room state" },
+  "qi/oracle.storeSecretsAndConfig": { displayName: "Store Oracle Secrets & Config", description: "Store oracle secrets and configuration in Matrix room state" },
+  "qi/outlook.email.send": { displayName: "Send Outlook email", description: "Send an email from the template author's Outlook account" },
+  "qi/pod.domain-indexer-lookup": { displayName: "Define Purpose", description: "Capture intent and find matching Blueprint candidates" },
+  "qi/pod.domain-single-selection": { displayName: "Select Blueprint", description: "Choose a Blueprint protocol for the POD" },
+  "qi/pod.entity-single-selection": { displayName: "Select Parent Organisation", description: "Pick a parent entity where you hold a role" },
+  "qi/pod.governance-config": { displayName: "Configure Governance", description: "Set the governance group type and decision policy" },
+  "qi/pod.list-domain-flows": { displayName: "Select Flow Templates", description: "Choose protocol flow templates to import" },
+  "qi/pod.member-multi-select": { displayName: "Configure Membership", description: "Define POD members, roles, and voting power" },
+  "qi/proposal.create": { displayName: "Create Proposal", description: "Create an on-chain governance proposal" },
+  "qi/proposal.vote": { displayName: "Vote on Proposal", description: "Cast a vote on a governance proposal" },
+  "qi/protocol.select": { displayName: "Select Protocol", description: "Select a protocol from a configured list" },
+  "qi/sandbox.provision": { displayName: "Provision Sandbox", description: "Provision a sandbox environment for the oracle" },
+  "qi/settlement.execute": { displayName: "Execute Settlement", description: "Execute an approved settlement using the configured provider" },
+  "qi/slack.message.send": { displayName: "Post Slack message", description: "Post a message to a channel from the template author's Slack account" },
+  "qi/topic.action.cancel": { displayName: "Cancel Topic Action", description: "Cancel an outstanding governed Action request" },
+  "qi/topic.action.receipt.record": { displayName: "Record Action Receipt", description: "Record a signed Action receipt against its Topic request" },
+  "qi/topic.action.request": { displayName: "Request Topic Action", description: "Request an Action against the current Topic revision" },
+  "qi/topic.context.link": { displayName: "Link Topic Context", description: "Link a referenced resource or service to the Topic" },
+  "qi/topic.contract.accept": { displayName: "Accept Topic Contract", description: "Accept the exact current Topic contract revision" },
+  "qi/topic.decision.record": { displayName: "Record Topic Decision", description: "Record an authorised decision and its rationale" },
+  "qi/topic.file.attach-reference": { displayName: "Attach File Reference", description: "Attach a pinned VFS file reference to the Topic" },
+  "qi/topic.flow.bind": { displayName: "Bind Flow to Topic", description: "Bind a governed Flow revision to the Topic" },
+  "qi/topic.flow.unbind": { displayName: "Unbind Flow from Topic", description: "Remove an existing Flow binding from the Topic" },
+  "qi/topic.outcome.confirm": { displayName: "Confirm Topic Outcome", description: "Confirm a proposed outcome using the stated authority" },
+  "qi/topic.outcome.propose": { displayName: "Propose Topic Outcome", description: "Propose an evidence-backed outcome for review" },
+  "qi/topic.status.transition": { displayName: "Change Topic Status", description: "Move the Topic between permitted lifecycle statuses" },
+  "qi/wallet.fund": { displayName: "Fund Wallet", description: "Fund a wallet with an on-chain transfer" },
+  "qi/wallet.generate": { displayName: "Generate Wallet", description: "Generate an IXO wallet and DID" },
+  "qi/wallet.generateAndFund": { displayName: "Generate & Fund Wallet", description: "Generate an IXO wallet and fund it on-chain" },
+  "qi/work.accept": { displayName: "Accept Work", description: "Accept submitted work using the stated authority" },
+  "qi/work.assign": { displayName: "Assign Work", description: "Assign a referenced unit of work" },
+  "qi/work.checkpoint": { displayName: "Record Work Checkpoint", description: "Record progress and evidence for work in progress" },
+  "qi/work.dispatch": { displayName: "Dispatch Work", description: "Dispatch assigned work to its assignee" },
+  "qi/work.submit": { displayName: "Submit Work", description: "Submit completed work for review" },
+  "qi/xero.contact.create": { displayName: "Create Xero contact", description: "Add a customer or supplier in Xero" },
+  "qi/xero.invoice.create": { displayName: "Create Xero invoice", description: "Draft a new Xero invoice" },
+  "qi/xero.invoice.list": { displayName: "List Xero invoices", description: "Fetch invoices from Xero" },
+  "qi/xero.payment.create": { displayName: "Record Xero payment", description: "Settle a Xero bill \u2014 typically wired to capture an on-chain tx hash as the reference" }
+};
+function humanizeActionType(type) {
+  const withoutNamespace = type.replace(/^qi\//, "").replace(/^oracle\.?/, "oracle ");
+  const words = withoutNamespace.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[./_-]+/).filter(Boolean);
+  return words.map((word) => /^(iid|kyc|dao|nft|http|dm|pod|cw20)$/i.test(word) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getActionPresentation(type) {
+  const registered = PRESENTATION[type];
+  if (registered) return registered;
+  const displayName = humanizeActionType(type) || "Action";
+  return { displayName, description: `Perform ${displayName.toLowerCase()} as part of this flow.` };
+}
+
 // src/core/lib/warnOnce.ts
 var seen = /* @__PURE__ */ new Set();
 function warnOnce(key, message) {
@@ -588,8 +1135,160 @@ function warnOnce(key, message) {
   console.warn(message);
 }
 
+// src/core/lib/actionRegistry/types.ts
+var TOPIC_ACTION_BASE_KINDS = ["task", "agent_task", "proposal", "evaluation", "claims", "question", "discussion", "incident"];
+var CollectionStateEnum = /* @__PURE__ */ ((CollectionStateEnum2) => {
+  CollectionStateEnum2[CollectionStateEnum2["OPEN"] = 0] = "OPEN";
+  CollectionStateEnum2[CollectionStateEnum2["PAUSED"] = 1] = "PAUSED";
+  CollectionStateEnum2[CollectionStateEnum2["CLOSED"] = 2] = "CLOSED";
+  return CollectionStateEnum2;
+})(CollectionStateEnum || {});
+
+// src/core/lib/actionRegistry/topicPolicy.ts
+var ALL_KINDS = [...TOPIC_ACTION_BASE_KINDS];
+var HUMAN_OWNED = [
+  /^qi\/human\./,
+  /^qi\/governance\./,
+  /^qi\/proposal\./,
+  /^qi\/(claim|bid)\.(submit|evaluate)$/,
+  /^qi\/(domain\.sign|entity\.|iid\.|identity\.|kyc\.)/,
+  /^qi\/(carbon\.(harvest|retire)|wallet\.fund)/,
+  /^qi\/xero\.(invoice|payment)\.create$/,
+  /^qi\/settlement\./,
+  /^qi\/topic\.(flow\.(bind|unbind)|status\.transition|contract\.accept|outcome\.confirm)$/,
+  /^qi\/work\.accept$/,
+  /^qi\/answer\.accept$/
+];
+var RESTRICTED = [/^qi\/oracle\.(configure|deploy|store)/i, /^qi\/(matrix\.register|sandbox\.provision|entity\.createOracle|wallet\.generate)/];
+function any(patterns, value) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function requiredServices(type) {
+  if (type.startsWith("qi/http.")) return ["http"];
+  if (type === "qi/email.send") return ["email"];
+  if (type === "qi/notification.push") return ["notifications"];
+  if (/^qi\/(gmail|outlook|slack|googlecalendar|calendar|xero)\./.test(type)) return ["integrations"];
+  if (/^qi\/flow\.run\./.test(type)) return ["flowRuns"];
+  if (/^qi\/blueprint\./.test(type)) return ["blueprint"];
+  if (/^qi\/bid\./.test(type)) return ["bid"];
+  if (/^qi\/claim\./.test(type)) return ["claim"];
+  if (type === "qi/collection.lifecycle") return ["collection"];
+  if (type === "qi/collection.users") return ["collectionUsers"];
+  if (/^qi\/(matrix\.dm|credential\.store)/.test(type)) return ["matrix"];
+  if (/^qi\/(oracle\.|wallet\.|iid\.|matrix\.register|identity\.|entity\.createOracle|sandbox\.)/.test(type) || type === "qi/oracle.invoke") return ["oracle"];
+  if (/^qi\/carbon\./.test(type)) return ["carbon"];
+  if (/^qi\/entity\.transfer/.test(type)) return ["entity"];
+  if (/^qi\/kyc\./.test(type)) return ["kyc"];
+  if (/^qi\/eval\./.test(type)) return ["evalRegister", "rubric"];
+  if (/^qi\/topic\./.test(type)) return ["topic"];
+  if (/^qi\/agent\./.test(type)) return ["agents"];
+  if (/^qi\/evidence\./.test(type)) return ["evidence"];
+  if (/^qi\/evaluation\./.test(type)) return ["evaluations"];
+  if (/^qi\/settlement\./.test(type)) return ["settlement"];
+  if (/^qi\/incident\.escalate/.test(type)) return ["incidents"];
+  if (/^qi\/(work|answer|incident\.mitigation)\./.test(type)) return ["topic"];
+  if (/^qi\/(governance|proposal|domain\.)\./.test(type)) return ["portalHandlers"];
+  return [];
+}
+function riskTier(action) {
+  const type = action.type;
+  if (/^qi\/(settlement\.execute|carbon\.retire)$/.test(type)) return "critical";
+  if (/^qi\/(governance\.|claim\.evaluate|entity\.transfer|domain\.sign|xero\.payment\.create|wallet\.fund)/.test(type)) return "high";
+  if (!action.sideEffect || /\.(list|loadBatches|card-preview|fetch)$/.test(type)) return "low";
+  return "medium";
+}
+function sensitivePaths(type) {
+  const input = [];
+  const output = [];
+  if (type.startsWith("qi/http.")) {
+    input.push("headers.authorization", "headers.cookie", "headers.x-api-key", "body");
+    output.push("data", "response");
+  }
+  if (/^qi\/(email|gmail|outlook|slack|notification|matrix\.dm)/.test(type)) {
+    input.push("to", "cc", "bcc", "body", "template", "variables");
+    output.push("providerResponse");
+  }
+  if (/^qi\/(gmail|outlook|slack|googlecalendar|calendar|xero)\./.test(type)) input.push("connection", "bindingId");
+  if (/^qi\/(kyc|credential)\./.test(type)) {
+    input.push("data", "credential");
+    output.push("credential", "surveyAnswers");
+  }
+  if (/^qi\/(oracle\.|wallet\.|iid\.|matrix\.register|identity\.|entity\.createOracle|sandbox\.)/.test(type)) {
+    input.push("mnemonic", "pin", "secrets", "config");
+    output.push("mnemonic", "privateKey", "matrixAccessToken", "matrixPassword", "matrixRecoveryPhrase", "secrets");
+  }
+  if (type === "qi/oracle.invoke") {
+    input.push("prompt");
+    output.push("result");
+  }
+  if (/^qi\/(form|human\.form|claim|bid)\./.test(type)) {
+    input.push("answers", "surveyAnswers", "surveyData");
+    output.push("answers", "surveyAnswers", "surveyData");
+  }
+  return { sensitiveInputPaths: [...new Set(input)].sort(), sensitiveOutputPaths: [...new Set(output)].sort() };
+}
+function topicKindsAndRelevance(type) {
+  if (any(RESTRICTED, type)) return { supportedBaseKinds: ["agent_task"], relevance: "restricted" };
+  if (/^qi\/flow\.run\./.test(type)) return { supportedBaseKinds: ALL_KINDS, relevance: "recommended" };
+  if (/^qi\/(oracle\.invoke|agent\.)/.test(type)) return { supportedBaseKinds: ["agent_task", "question", "task"], relevance: "recommended" };
+  if (/^qi\/(governance\.|proposal\.|topic\.decision)/.test(type)) return { supportedBaseKinds: ["proposal", "discussion", "evaluation"], relevance: "recommended" };
+  if (/^qi\/(eval\.|evaluation\.)/.test(type)) return { supportedBaseKinds: ["evaluation", "claims"], relevance: "recommended" };
+  if (/^qi\/(claim\.|collection\.|settlement\.)/.test(type)) return { supportedBaseKinds: ["claims", "evaluation"], relevance: "recommended" };
+  if (/^qi\/(work\.)/.test(type)) return { supportedBaseKinds: ["task", "discussion", "incident"], relevance: "recommended" };
+  if (/^qi\/(evidence\.|answer\.)/.test(type)) return { supportedBaseKinds: ["question", "evaluation"], relevance: "recommended" };
+  if (/^qi\/incident\./.test(type)) return { supportedBaseKinds: ["incident"], relevance: "recommended" };
+  if (/^qi\/topic\./.test(type)) return { supportedBaseKinds: ALL_KINDS, relevance: "recommended" };
+  if (/^qi\/(http\.|domain\.card-preview|calendar\.|googlecalendar\.)/.test(type))
+    return { supportedBaseKinds: ["question", "evaluation", "agent_task", "task"], relevance: "contextual" };
+  if (/^qi\/(email\.|gmail\.|outlook\.|slack\.|matrix\.dm|notification\.)/.test(type)) {
+    return { supportedBaseKinds: ["task", "question", "discussion", "incident"], relevance: "contextual" };
+  }
+  return { supportedBaseKinds: ALL_KINDS, relevance: "contextual" };
+}
+function topicSemanticRecords(type) {
+  if (/^qi\/(governance\.|proposal\.)/.test(type)) return ["org.ixo.topic.proposal-receipt"];
+  if (/^qi\/claim\.submit/.test(type)) return ["org.ixo.topic.claim-submission"];
+  if (/^qi\/claim\.evaluate/.test(type)) return ["org.ixo.topic.claim-evaluation"];
+  if (/^qi\/evaluation\./.test(type)) return ["org.ixo.topic.evaluation-assertion"];
+  return [];
+}
+function normalizeActionPolicy(action) {
+  const sensitive = sensitivePaths(action.type);
+  const topicSelection = topicKindsAndRelevance(action.type);
+  const semanticRecords = topicSemanticRecords(action.type);
+  const declaredTopic = action.topic;
+  const sensitiveInputPaths = [.../* @__PURE__ */ new Set([...action.sensitiveInputPaths || [], ...sensitive.sensitiveInputPaths])].sort();
+  const sensitiveOutputPaths = [.../* @__PURE__ */ new Set([...action.sensitiveOutputPaths || [], ...sensitive.sensitiveOutputPaths])].sort();
+  return {
+    executionOwner: action.executionOwner || (any(HUMAN_OWNED, action.type) ? "human" : "agent"),
+    riskTier: action.riskTier || riskTier(action),
+    requiredServices: [...new Set(action.requiredServices || requiredServices(action.type))].sort(),
+    sensitiveInputPaths,
+    sensitiveOutputPaths,
+    topic: declaredTopic ? {
+      ...declaredTopic,
+      semanticRecordTypes: declaredTopic.semanticRecordTypes || getTopicSemanticRecordDefinitions(declaredTopic.permittedTopicRecordTypes),
+      permittedTopicRecordTypes: (declaredTopic.semanticRecordTypes || getTopicSemanticRecordDefinitions(declaredTopic.permittedTopicRecordTypes)).map(
+        (definition) => definition.type
+      )
+    } : {
+      ...topicSelection,
+      writeBackMode: semanticRecords.length > 0 ? "semantic-record" : "receipt-only",
+      semanticRecordTypes: getTopicSemanticRecordDefinitions(semanticRecords),
+      permittedTopicRecordTypes: semanticRecords,
+      lifecycleEffect: "none",
+      requiredTopicAbilities: ["topic/request-action", "topic/record-action"],
+      redactionPolicy: { mode: "paths", sensitiveInputPaths, sensitiveOutputPaths }
+    }
+  };
+}
+
 // src/core/lib/actionRegistry/registry.ts
 var actions = /* @__PURE__ */ new Map();
+var registryRevision = 0;
+function getRegistryRevision() {
+  return registryRevision;
+}
 var STEP_COMPLETED_EVENT_NAME = "step.completed";
 var STEP_COMPLETED_EVENT = {
   name: STEP_COMPLETED_EVENT_NAME,
@@ -604,6 +1303,7 @@ var neverDone = {
   isDone: () => false
 };
 var ACTION_TYPE_ALIASES = {
+  oracle: "qi/oracle.invoke",
   bid: "qi/bid.submit",
   claim: "qi/claim.submit",
   evaluateBid: "qi/bid.evaluate",
@@ -627,7 +1327,16 @@ var ACTION_TYPE_ALIASES = {
   MemberMultiSelect: "qi/pod.member-multi-select",
   governanceConfig: "qi/pod.governance-config",
   listDomainFlows: "qi/pod.list-domain-flows",
-  "matrix.dm": "qi/matrix.dm"
+  "matrix.dm": "qi/matrix.dm",
+  // The qi/calendar.* namespace is retired permanently (IXO-4420 §5): these
+  // blocks were always Google Calendar via Composio, misnamed as neutral.
+  // Aliases keep every existing document loading; because resolveActionType
+  // checks aliases before registered types, no new canonical action can ever
+  // be registered under these names — the IXO-native calendar (M4) takes
+  // qi/ixo.calendar.event.* instead.
+  "qi/calendar.event.create": "qi/googlecalendar.event.create-self",
+  "qi/calendar.event.update": "qi/googlecalendar.event.update-self",
+  "qi/calendar.event.list": "qi/googlecalendar.event.list-self"
 };
 var aliases = new Map(Object.entries(ACTION_TYPE_ALIASES));
 function resolveActionType(type) {
@@ -678,13 +1387,17 @@ function capabilityPatternCoversCan(pattern, can, options = {}) {
   return false;
 }
 function registerAction(definition) {
-  const normalized = definition.can ? { ...definition, can: normalizeCan(definition.can) } : definition;
-  if (!normalized.done) {
+  const presentation = getActionPresentation(definition.type);
+  definition.displayName = definition.displayName?.trim() || presentation.displayName;
+  definition.description = definition.description?.trim() || presentation.description;
+  if (definition.can) definition.can = normalizeCan(definition.can);
+  Object.assign(definition, normalizeActionPolicy(definition));
+  if (!definition.done) {
     warnOnce(`missing-done-contract:${definition.type}`, `[flow-config] action ${definition.type}: no done contract declared; defaulting to state === 'completed'`);
-    actions.set(definition.type, { ...normalized, done: doneWhenCompleted });
-    return;
+    definition.done = doneWhenCompleted;
   }
-  actions.set(definition.type, normalized);
+  actions.set(definition.type, definition);
+  registryRevision += 1;
 }
 function getAction(type) {
   return actions.get(resolveActionType(type));
@@ -770,6 +1483,8 @@ function normalizeInputs(inputs) {
 }
 
 // src/core/lib/actionRegistry/manifest.ts
+var ACTION_MANIFEST_VERSION = "4";
+var ACTION_REGISTRY_VERSION = "6.32.0-topic-actions.3";
 function serializeProof(action) {
   const proof = action.proof;
   if (proof === "none" || proof === void 0) return { kind: "none" };
@@ -784,42 +1499,106 @@ function serializeDone(action) {
     cardinality: action.cardinality || "once"
   };
 }
-function generateActionManifest() {
-  const aliasEntries = getAliasEntries();
+function serializeAction(action, aliases2) {
+  const can = action.can || actionTypeToCan(action.type) || "";
+  return {
+    type: action.type,
+    displayName: action.displayName,
+    description: action.description,
+    aliases: aliases2,
+    can,
+    effectiveCapability: {
+      action: can,
+      ...action.requiredCapability ? { flowExecution: action.requiredCapability } : {},
+      topicWriteBack: [...action.topic?.requiredTopicAbilities || []].sort()
+    },
+    sideEffect: action.sideEffect,
+    defaultRequiresConfirmation: action.defaultRequiresConfirmation,
+    executionOwner: action.executionOwner || "agent",
+    riskTier: action.riskTier || "medium",
+    requiredServices: [...action.requiredServices || []].sort(),
+    sensitiveInputPaths: [...action.sensitiveInputPaths || []].sort(),
+    sensitiveOutputPaths: [...action.sensitiveOutputPaths || []].sort(),
+    hidden: action.hiddenFromAuthoring === true,
+    deprecated: action.deprecated === true,
+    ...action.supersededBy ? { supersededBy: action.supersededBy } : {},
+    proof: serializeProof(action),
+    done: serializeDone(action),
+    inputSchema: action.inputSchema || {},
+    outputSchema: action.outputSchema || [],
+    events: (action.events || []).map((event) => ({
+      name: event.name,
+      displayName: event.displayName,
+      description: event.description,
+      payloadSchema: event.payloadSchema
+    })),
+    hasDynamicEvents: !!action.getDynamicEvents,
+    hasDynamicOutputSchema: !!action.getDynamicOutputSchema,
+    eligibleForEventTrigger: !!action.eligibleForEventTrigger,
+    eligibleForTimeTrigger: !!action.eligibleForTimeTrigger,
+    ...action.scheduling ? { scheduling: action.scheduling } : {},
+    hasCustomInputValidation: !!action.getMissingInputs,
+    topic: action.topic
+  };
+}
+function contractDigestPayload(entry) {
+  const { displayName: _displayName, description: _description, topic, ...contract } = entry;
+  const { semanticRecordTypes, ...legacyTopic } = topic;
+  const semanticContracts = semanticRecordTypes.map(({ displayName: _recordDisplayName, description: _recordDescription, ...definition }) => definition);
+  return {
+    ...contract,
+    topic: semanticContracts.length > 0 ? { ...legacyTopic, semanticRecordTypes: semanticContracts } : legacyTopic
+  };
+}
+function buildActionManifest() {
   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),
-      done: serializeDone(action),
-      hasDynamicEvents: !!action.getDynamicEvents,
-      hasDynamicOutputSchema: !!action.getDynamicOutputSchema,
-      eligibleForEventTrigger: !!action.eligibleForEventTrigger,
-      hasCustomInputValidation: !!action.getMissingInputs
-    };
-    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 };
+  for (const [alias, canonical] of getAliasEntries()) {
+    aliasesByType.set(canonical, [...aliasesByType.get(canonical) || [], alias]);
+  }
+  const actions2 = getAllActions().map((action) => serializeAction(action, [...aliasesByType.get(action.type) || []].sort(compareCodeUnits))).sort((a, b) => compareCodeUnits(a.type, b.type)).map((entry) => ({ ...entry, contractDigest: sha256Digest(contractDigestPayload(entry)) }));
+  const payload = { manifestVersion: ACTION_MANIFEST_VERSION, registryVersion: ACTION_REGISTRY_VERSION, actions: actions2 };
+  return { ...payload, manifestDigest: sha256Digest(payload) };
+}
+var cached;
+function generateActionManifest() {
+  const revision = getRegistryRevision();
+  if (cached && cached.revision === revision) return cached.manifest;
+  const manifest = buildActionManifest();
+  cached = { revision, manifest };
+  return manifest;
+}
+function actionManifestIssues(manifest = generateActionManifest()) {
+  const issues = [];
+  for (const action of manifest.actions) {
+    const publicAction = !action.hidden;
+    if (!action.can) issues.push({ actionType: action.type, code: "MISSING_CAN", message: "Action has no canonical can ability." });
+    if (!action.displayName.trim() || !action.description.trim() || action.displayName === action.type || action.description.includes(action.type) || /^Perform .* as part of this flow\.$/.test(action.description)) {
+      issues.push({ actionType: action.type, code: "MISSING_PRESENTATION", message: "Action needs a non-technical display name and description." });
+    }
+    if (publicAction && Object.keys(action.inputSchema).length === 0) {
+      issues.push({ actionType: action.type, code: "MISSING_INPUT_SCHEMA", message: "Public Action has no input schema." });
+    }
+    if (publicAction && action.outputSchema.length === 0 && !action.hasDynamicOutputSchema) {
+      issues.push({ actionType: action.type, code: "MISSING_OUTPUT_SCHEMA", message: "Public Action has no output schema." });
+    }
+    if (action.sideEffect && action.proof.kind === "none") {
+      issues.push({ actionType: action.type, code: "SIDE_EFFECT_WITHOUT_PROOF", message: "Side-effecting Action declares no proof." });
+    }
+    if (!action.topic) issues.push({ actionType: action.type, code: "MISSING_TOPIC_POLICY", message: "Action has no Topic compatibility policy." });
+    else if (action.topic.lifecycleEffect !== "none" || action.topic.supportedBaseKinds.length === 0) {
+      issues.push({ actionType: action.type, code: "INVALID_TOPIC_POLICY", message: "Topic policy must support a base Kind and cannot imply lifecycle effects." });
+    }
+    if (action.topic.semanticRecordTypes.some(
+      (definition) => !definition.type || !definition.version || !definition.displayName.trim() || !definition.description.trim() || Object.keys(definition.valueSchema).length === 0
+    ) || action.topic.permittedTopicRecordTypes.join("|") !== action.topic.semanticRecordTypes.map((definition) => definition.type).join("|")) {
+      issues.push({
+        actionType: action.type,
+        code: "INVALID_SEMANTIC_RECORD_DEFINITION",
+        message: "Topic semantic record definitions must be complete and determine the compatibility type list."
+      });
+    }
+  }
+  return issues;
 }
 
 // src/core/lib/actionRegistry/inputRequirements.ts
@@ -938,7 +1717,8 @@ function buildServicesFromHandlers(handlers) {
       request: async (params) => {
         const fetchOptions = {
           method: params.method,
-          headers: { "Content-Type": "application/json", ...params.headers }
+          headers: { "Content-Type": "application/json", ...params.headers },
+          redirect: "error"
         };
         if (params.method !== "GET" && params.body) {
           fetchOptions.body = typeof params.body === "string" ? params.body : JSON.stringify(params.body);
@@ -952,7 +1732,9 @@ function buildServicesFromHandlers(handlers) {
         return {
           status: res.status,
           headers: responseHeaders,
-          data
+          data,
+          responseDigest: sha256Digest(data),
+          requestId: sha256Digest({ url: params.url, method: params.method, status: res.status, data })
         };
       }
     },
@@ -2212,6 +2994,182 @@ for (const spec of ACTIONS) {
   });
 }
 
+// src/core/lib/actionRegistry/actions/governance/_shared.ts
+var GOVERNANCE_REQUIRED_FIELDS = {
+  "qi/governance.authz.exec": ["authzExecActionType"],
+  "qi/governance.authz.grant": ["grantee", "msgTypeUrl"],
+  "qi/governance.authz.revoke": ["grantee", "msgTypeUrl"],
+  "qi/governance.chain-governance-vote": ["proposalId", "vote"],
+  "qi/governance.contract.execute": ["address", "message"],
+  "qi/governance.contract.instantiate": ["codeId", "label", "message"],
+  "qi/governance.contract.manage-cw20": ["adding", "address"],
+  "qi/governance.contract.migrate": ["contract", "codeId", "msg"],
+  "qi/governance.contract.update-admin": ["contract", "newAdmin"],
+  "qi/governance.custom-message": ["message"],
+  "qi/governance.dao.accept-to-marketplace": ["did", "relayerNodeAddress", "relayerNodeDid"],
+  "qi/governance.dao.admin-exec": ["targetCoreAddress", "msgs"],
+  "qi/governance.dao.create-entity": ["typeUrl", "value"],
+  "qi/governance.dao.join": ["entityDid", "memberId"],
+  "qi/governance.dao.manage-storage": ["setting", "key", "value"],
+  "qi/governance.dao.manage-subdaos": [],
+  "qi/governance.dao.update-info": ["name"],
+  "qi/governance.member-proposal": ["operation", "members"],
+  "qi/governance.nft.burn": ["collection", "tokenId"],
+  "qi/governance.nft.manage-collections": ["adding", "address"],
+  "qi/governance.nft.transfer": ["collection", "tokenId", "recipient"],
+  "qi/governance.staking.stake": ["stakeType", "amount"],
+  "qi/governance.staking.stake-to-group": ["tokenContract", "stakingContract", "amount"],
+  "qi/governance.settings-proposal": ["votingPeriodHours", "quorumPercent", "thresholdPercent"],
+  "qi/governance.submission-config-proposal": ["anyoneCanPropose", "depositRequired"],
+  "qi/governance.transaction.mint": ["recipient", "amount"],
+  "qi/governance.transaction.send-funds": ["recipient", "denom", "amount"],
+  "qi/governance.transaction.perform-token-swap": ["tokenSwapContractAddress", "selfPartyType", "selfPartyDenomOrAddress", "selfPartyAmount"],
+  "qi/governance.transaction.send-group-token": ["tokenContract", "recipient", "amount"],
+  "qi/governance.transaction.withdraw-token-swap": ["tokenSwapContractAddress"],
+  "qi/governance.validator.actions": ["validatorActionType"]
+};
+var GOVERNANCE_FIELDS = {
+  "qi/governance.authz.exec": ["authzExecActionType", "delegatorAddress", "validatorAddress", "validatorDstAddress", "amount", "custom"],
+  "qi/governance.authz.grant": ["grantee", "msgTypeUrl"],
+  "qi/governance.authz.revoke": ["grantee", "msgTypeUrl"],
+  "qi/governance.chain-governance-vote": ["proposalId", "vote"],
+  "qi/governance.contract.execute": ["address", "message", "funds"],
+  "qi/governance.contract.instantiate": ["codeId", "label", "admin", "message", "funds"],
+  "qi/governance.contract.manage-cw20": ["adding", "address"],
+  "qi/governance.contract.migrate": ["contract", "codeId", "msg"],
+  "qi/governance.contract.update-admin": ["contract", "newAdmin"],
+  "qi/governance.custom-message": ["message"],
+  "qi/governance.dao.accept-to-marketplace": ["did", "relayerNodeAddress", "relayerNodeDid"],
+  "qi/governance.dao.admin-exec": ["targetCoreAddress", "msgs"],
+  "qi/governance.dao.create-entity": ["typeUrl", "value"],
+  "qi/governance.dao.join": ["entityDid", "memberId"],
+  "qi/governance.dao.manage-storage": ["setting", "key", "value"],
+  "qi/governance.dao.manage-subdaos": ["toAdd", "toRemove"],
+  "qi/governance.dao.update-info": ["name", "daoDescription", "imageUrl", "automaticallyAddCw20s", "automaticallyAddCw721s"],
+  "qi/governance.member-proposal": ["operation", "members"],
+  "qi/governance.nft.burn": ["collection", "tokenId"],
+  "qi/governance.nft.manage-collections": ["adding", "address"],
+  "qi/governance.nft.transfer": ["collection", "tokenId", "recipient", "executeSmartContract", "smartContractMsg"],
+  "qi/governance.staking.stake": ["stakeType", "validator", "toValidator", "amount"],
+  "qi/governance.staking.stake-to-group": ["tokenContract", "stakingContract", "amount"],
+  "qi/governance.settings-proposal": ["votingPeriodHours", "quorumPercent", "thresholdPercent", "allowRevoting"],
+  "qi/governance.submission-config-proposal": ["anyoneCanPropose", "depositRequired", "depositAmount", "depositRefundPolicy"],
+  "qi/governance.transaction.mint": ["recipient", "amount"],
+  "qi/governance.transaction.send-funds": ["recipient", "denom", "amount"],
+  "qi/governance.transaction.perform-token-swap": ["tokenSwapContractAddress", "selfPartyType", "selfPartyDenomOrAddress", "selfPartyAmount"],
+  "qi/governance.transaction.send-group-token": ["tokenContract", "recipient", "amount"],
+  "qi/governance.transaction.withdraw-token-swap": ["tokenSwapContractAddress"],
+  "qi/governance.validator.actions": ["validatorActionType", "createMsg", "editMsg"]
+};
+var BOOLEAN_FIELDS = /* @__PURE__ */ new Set(["adding", "automaticallyAddCw20s", "automaticallyAddCw721s", "executeSmartContract", "anyoneCanPropose", "depositRequired", "allowRevoting"]);
+var NUMBER_FIELDS = /* @__PURE__ */ new Set(["codeId", "vote", "votingPeriodHours", "quorumPercent", "thresholdPercent"]);
+var ARRAY_FIELDS = /* @__PURE__ */ new Set(["funds", "msgs", "toAdd", "toRemove", "members"]);
+var OBJECT_FIELDS = /* @__PURE__ */ new Set(["value"]);
+function governanceProperty(name) {
+  if (BOOLEAN_FIELDS.has(name)) return { type: "boolean" };
+  if (NUMBER_FIELDS.has(name)) return { type: "number" };
+  if (ARRAY_FIELDS.has(name)) return { type: "array", items: {} };
+  if (OBJECT_FIELDS.has(name)) return { type: "object" };
+  return { type: "string" };
+}
+function governanceInputSchema(type, extraFields = {}, requiredOverride) {
+  const properties = {
+    coreAddress: { type: "string", description: "DAO core contract address." },
+    title: { type: "string", description: "Proposal title voters see." },
+    description: { type: "string", description: "Long-form proposal description voters see." }
+  };
+  for (const field of GOVERNANCE_FIELDS[type] || []) properties[field] = governanceProperty(field);
+  Object.assign(properties, extraFields);
+  return {
+    type: "object",
+    required: ["coreAddress", ...requiredOverride || GOVERNANCE_REQUIRED_FIELDS[type] || []],
+    additionalProperties: false,
+    properties
+  };
+}
+var STANDARD_OUTPUT_SCHEMA = [
+  { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
+  { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
+  { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
+  { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
+  { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
+  { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
+  { path: "createdAt", displayName: "Created At", type: "string", description: "ISO timestamp of proposal creation" }
+];
+function registerGovernanceProposalAction(spec) {
+  registerAction({
+    type: spec.type,
+    can: spec.can,
+    sideEffect: true,
+    proof: { fields: ["proposalId"] },
+    done: doneWhenCompleted,
+    defaultRequiresConfirmation: true,
+    requiredCapability: "flow/block/execute",
+    inputSchema: governanceInputSchema(spec.type),
+    outputSchema: [...STANDARD_OUTPUT_SCHEMA, ...spec.extraOutputSchema || []],
+    run: async (inputs, ctx) => {
+      const handlers = ctx.handlers;
+      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 actions2 = spec.buildActions(inputs);
+      if (!actions2.length) throw new Error("The proposal must contain at least one action");
+      const title = String(inputs.title || "").trim() || spec.defaultTitle(inputs);
+      const description = String(inputs.description || "").trim() || (spec.defaultDescription ? spec.defaultDescription(inputs) : title);
+      const { preProposalContractAddress } = await handlers.getPreProposalContractAddress({ coreAddress });
+      const { groupContractAddress } = await handlers.getGroupContractAddress({ coreAddress });
+      const { proposalContractAddress } = await handlers.getProposalContractAddress({ coreAddress });
+      const proposalId = await handlers.createProposal({
+        preProposalContractAddress,
+        title,
+        description,
+        actions: actions2,
+        coreAddress,
+        groupContractAddress
+      });
+      if (proposalId === void 0 || proposalId === null || String(proposalId).trim() === "") {
+        throw new Error("Proposal creation returned no proposal id. Check the handler logs.");
+      }
+      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      const output = {
+        proposalId: String(proposalId),
+        proposalTitle: title,
+        proposalDescription: description,
+        status: "open",
+        proposalContractAddress: proposalContractAddress || "",
+        coreAddress,
+        createdAt,
+        ...spec.buildExtraOutput ? spec.buildExtraOutput(inputs) : {}
+      };
+      return {
+        output,
+        topicRecords: ctx.topic ? [
+          {
+            type: "org.ixo.topic.proposal-receipt",
+            id: sha256Digest({ topicId: ctx.topic.topicId, proposalContractAddress, proposalId }),
+            version: 1,
+            value: {
+              event: "created",
+              actionType: spec.type,
+              proposalId: String(proposalId),
+              proposalContractAddress: proposalContractAddress || "",
+              coreAddress,
+              proposalTitle: title,
+              proposalDescriptionDigest: sha256Digest(description),
+              createdAt
+            }
+          }
+        ] : void 0
+      };
+    }
+  });
+}
+
 // src/core/lib/actionRegistry/actions/governance/memberProposal.ts
 var VALID_OPERATIONS = ["add", "remove", "update-weight"];
 function defaultTitle(operation, count) {
@@ -2233,6 +3191,7 @@ registerAction({
   done: doneWhenCompleted,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
+  inputSchema: governanceInputSchema("qi/governance.member-proposal"),
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
     { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
@@ -2333,6 +3292,7 @@ registerAction({
   done: doneWhenCompleted,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
+  inputSchema: governanceInputSchema("qi/governance.settings-proposal"),
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
     { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
@@ -2414,70 +3374,6 @@ registerAction({
   }
 });
 
-// src/core/lib/actionRegistry/actions/governance/_shared.ts
-var STANDARD_OUTPUT_SCHEMA = [
-  { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
-  { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
-  { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
-  { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
-  { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
-  { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
-  { path: "createdAt", displayName: "Created At", type: "string", description: "ISO timestamp of proposal creation" }
-];
-function registerGovernanceProposalAction(spec) {
-  registerAction({
-    type: spec.type,
-    can: spec.can,
-    sideEffect: true,
-    proof: { fields: ["proposalId"] },
-    done: doneWhenCompleted,
-    defaultRequiresConfirmation: true,
-    requiredCapability: "flow/block/execute",
-    outputSchema: [...STANDARD_OUTPUT_SCHEMA, ...spec.extraOutputSchema || []],
-    run: async (inputs, ctx) => {
-      const handlers = ctx.handlers;
-      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 actions2 = spec.buildActions(inputs);
-      if (!actions2.length) throw new Error("The proposal must contain at least one action");
-      const title = String(inputs.title || "").trim() || spec.defaultTitle(inputs);
-      const description = String(inputs.description || "").trim() || (spec.defaultDescription ? spec.defaultDescription(inputs) : title);
-      const { preProposalContractAddress } = await handlers.getPreProposalContractAddress({ coreAddress });
-      const { groupContractAddress } = await handlers.getGroupContractAddress({ coreAddress });
-      const { proposalContractAddress } = await handlers.getProposalContractAddress({ coreAddress });
-      const proposalId = await handlers.createProposal({
-        preProposalContractAddress,
-        title,
-        description,
-        actions: actions2,
-        coreAddress,
-        groupContractAddress
-      });
-      if (proposalId === void 0 || proposalId === null || String(proposalId).trim() === "") {
-        throw new Error("Proposal creation returned no proposal id. Check the handler logs.");
-      }
-      return {
-        output: {
-          proposalId: String(proposalId),
-          proposalTitle: title,
-          proposalDescription: description,
-          status: "open",
-          proposalContractAddress: proposalContractAddress || "",
-          coreAddress,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...spec.buildExtraOutput ? spec.buildExtraOutput(inputs) : {}
-        }
-      };
-    }
-  });
-}
-
 // src/core/lib/actionRegistry/actions/governance/submissionConfigProposal.ts
 var REFUND_POLICIES = ["always", "only_passed", "never"];
 registerGovernanceProposalAction({
@@ -2539,6 +3435,7 @@ registerAction({
   done: doneWhenCompleted,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
+  inputSchema: governanceInputSchema("qi/governance.transaction.send-funds"),
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
     { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
@@ -3458,66 +4355,157 @@ registerGovernanceProposalAction({
 });
 
 // src/core/lib/actionRegistry/actions/httpRequest.ts
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set(["authorization", "cookie", "proxy-authorization", "x-api-key"]);
+var MUTATING_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
+var REQUEST_METHODS = [...MUTATING_METHODS, "GET", "HEAD"];
+function publicHttpUrl(raw) {
+  const value = String(raw || "").trim();
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("HTTP endpoint must be an absolute URL");
+  }
+  if (url.protocol !== "https:") throw new Error("HTTP Actions require an HTTPS endpoint");
+  if (url.username || url.password) throw new Error("Credentials must not be embedded in an HTTP endpoint");
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host === "::1" || host.startsWith("fc") || host.startsWith("fd") || host.startsWith("fe80:") || /^127\./.test(host) || /^10\./.test(host) || /^169\.254\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host) || host === "0.0.0.0") {
+    throw new Error("HTTP endpoint must not resolve to a local, private, link-local, or metadata address");
+  }
+  return url.toString();
+}
+function safeHeaders(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const headers = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+      throw new Error(`Sensitive header '${key}' must be supplied through a host-managed credential binding, not Action input`);
+    }
+    headers[key] = String(value);
+  }
+  return headers;
+}
+var INPUT_PROPERTIES = {
+  endpoint: { type: "string", format: "uri", description: "Public HTTPS request URL. Either endpoint or url is required." },
+  url: { type: "string", format: "uri", description: "Legacy alias for endpoint." },
+  method: { type: "string", description: "HTTP method." },
+  headers: { type: "object", additionalProperties: { type: "string" }, description: "Non-secret request headers. Authorization and cookies are rejected." },
+  body: { description: "Request body for a mutating HTTP request." }
+};
+var OUTPUT_SCHEMA2 = [
+  { path: "requestId", displayName: "Request ID", type: "string", description: "Host invocation identifier." },
+  { path: "status", displayName: "HTTP Status", type: "number" },
+  { path: "responseDigest", displayName: "Response Digest", type: "string", description: "Digest of the response body." },
+  { path: "data", displayName: "Response Data", type: "object", description: "Full result retained in the Flow timeline, not copied into Topic state." },
+  { path: "response", displayName: "Response JSON", type: "string" },
+  { path: "traceReference", displayName: "Trace Reference", type: "string" }
+];
+function missingEndpoint(inputs) {
+  return String(inputs.endpoint || inputs.url || "").trim() ? [] : ["endpoint"];
+}
 registerAction({
-  type: "qi/http.request",
-  can: "http/request",
+  type: "qi/http.fetch",
+  can: "http/fetch",
   sideEffect: false,
-  proof: { fields: ["status"] },
+  proof: { fields: ["responseDigest"] },
   done: doneWhenCompleted,
   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
-  // events-and-triggers plan.
   eligibleForEventTrigger: true,
   inputSchema: {
     type: "object",
-    required: ["endpoint"],
-    properties: {
-      endpoint: { type: "string", description: "The request URL. Either endpoint or its alias url must be provided." },
-      url: { type: "string", description: "Alias for endpoint; the request URL. Either url or endpoint satisfies the URL requirement." },
-      method: { type: "string", description: "HTTP method (GET, POST, etc.). Defaults to GET." },
-      headers: { type: "object", description: "Request headers as a key/value map." },
-      body: { type: "string", description: "Request body; sent for non-GET methods. Accepts a string or an object (serialized to JSON)." }
-    }
+    required: [],
+    additionalProperties: false,
+    properties: { ...INPUT_PROPERTIES, method: { type: "string", enum: ["GET", "HEAD"], default: "GET" } }
   },
-  // run() accepts `endpoint` OR `url` — mirror the alias the schema's
-  // required array can't express.
-  getMissingInputs: (inputs) => String(inputs.endpoint || inputs.url || "").trim() ? [] : ["endpoint"],
+  getMissingInputs: missingEndpoint,
+  outputSchema: OUTPUT_SCHEMA2,
   run: async (inputs, ctx) => {
-    const endpoint = inputs.endpoint ?? inputs.url;
-    const url = typeof endpoint === "string" ? endpoint : "";
-    if (!url) {
-      throw new Error("HTTP request action requires an endpoint or url input");
-    }
-    const method = typeof inputs.method === "string" ? inputs.method : "GET";
-    const headers = inputs.headers && typeof inputs.headers === "object" && !Array.isArray(inputs.headers) ? inputs.headers : {};
-    const body = inputs.body;
-    const requestFn = ctx.services.http?.request;
-    if (requestFn) {
-      const result = await requestFn({ url, method, headers, body });
+    const url = publicHttpUrl(inputs.endpoint ?? inputs.url);
+    const method = String(inputs.method || "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD") throw new Error("qi/http.fetch permits GET or HEAD only");
+    const headers = safeHeaders(inputs.headers);
+    const service = ctx.services.http;
+    if (service) {
+      const result = await service.request({
+        url,
+        method,
+        headers,
+        security: { denyPrivateNetworks: true, maxRedirects: 0, stripSensitiveHeadersOnRedirect: true }
+      });
+      const responseDigest2 = result.responseDigest || sha256Digest(result.data);
       return {
         output: {
+          requestId: result.requestId || responseDigest2,
           status: result.status,
+          responseDigest: responseDigest2,
           data: result.data,
-          response: JSON.stringify(result.data, null, 2)
+          response: JSON.stringify(result.data, null, 2),
+          traceReference: result.traceReference || ""
         }
       };
     }
-    const fetchOptions = {
-      method,
-      headers: { "Content-Type": "application/json", ...headers }
-    };
-    if (method !== "GET" && body) {
-      fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+    const response = await fetch(url, { method, headers, redirect: "error" });
+    const text = method === "HEAD" ? "" : await response.text();
+    let data = text;
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
     }
-    const response = await fetch(url, fetchOptions);
-    const data = await response.json().catch(() => ({}));
+    const responseDigest = sha256Digest(data);
     return {
       output: {
+        requestId: responseDigest,
         status: response.status,
+        responseDigest,
         data,
-        response: JSON.stringify(data, null, 2)
+        response: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+        traceReference: ""
+      }
+    };
+  }
+});
+registerAction({
+  type: "qi/http.request",
+  can: "http/request",
+  sideEffect: true,
+  proof: { fields: ["requestId"] },
+  done: doneWhenCompleted,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  inputSchema: {
+    type: "object",
+    required: [],
+    additionalProperties: false,
+    properties: {
+      ...INPUT_PROPERTIES,
+      method: {
+        type: "string",
+        enum: REQUEST_METHODS,
+        default: "GET",
+        description: "POST/PUT/PATCH/DELETE for mutations. GET/HEAD remain accepted for legacy Flows but use the same confirmation and receipt policy; new read Actions should use qi/http.fetch."
       }
+    }
+  },
+  getMissingInputs: missingEndpoint,
+  outputSchema: OUTPUT_SCHEMA2,
+  run: async (inputs, ctx) => {
+    const service = ctx.services.http;
+    if (!service) throw new Error("Mutating HTTP requests require the host HTTP service; native fetch is not permitted");
+    const url = publicHttpUrl(inputs.endpoint ?? inputs.url);
+    const method = String(inputs.method || "GET").toUpperCase();
+    if (!REQUEST_METHODS.includes(method)) throw new Error(`qi/http.request method must be one of ${REQUEST_METHODS.join(", ")}`);
+    const result = await service.request({
+      url,
+      method,
+      headers: safeHeaders(inputs.headers),
+      body: inputs.body,
+      security: { denyPrivateNetworks: true, maxRedirects: 0, stripSensitiveHeadersOnRedirect: true }
+    });
+    const responseDigest = result.responseDigest || sha256Digest(result.data);
+    const requestId = result.requestId || sha256Digest({ url, method, status: result.status, responseDigest });
+    return {
+      output: { requestId, status: result.status, responseDigest, data: result.data, response: JSON.stringify(result.data, null, 2), traceReference: result.traceReference || "" }
     };
   }
 });
@@ -3602,7 +4590,7 @@ registerAction({
   type: "qi/human.checkbox.set",
   can: "human/checkbox",
   sideEffect: true,
-  proof: "none",
+  proof: { fields: ["attestationId"] },
   done: doneWhenCompleted,
   defaultRequiresConfirmation: false,
   requiredCapability: "flow/execute",
@@ -3613,9 +4601,17 @@ registerAction({
       checked: { type: "boolean", description: "Whether the checkbox should be checked (defaults to true)." }
     }
   },
-  run: async (inputs) => {
+  outputSchema: [
+    { path: "checked", displayName: "Checked", type: "boolean" },
+    { path: "attestationId", displayName: "Attestation ID", type: "string", description: "Proof identifier for the human checkbox attestation." },
+    { path: "attestedAt", displayName: "Attested At", type: "string" },
+    { path: "attestedBy", displayName: "Attested By", type: "string" }
+  ],
+  run: async (inputs, ctx) => {
     const checked = inputs.checked !== void 0 ? !!inputs.checked : true;
-    return { output: { checked } };
+    const attestedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const attestationId = sha256Digest({ action: "qi/human.checkbox.set", checked, actorDid: ctx.actorDid, flowId: ctx.flowId, nodeId: ctx.nodeId, attestedAt });
+    return { output: { checked, attestationId, attestedAt, attestedBy: ctx.actorDid } };
   }
 });
 
@@ -3645,7 +4641,7 @@ function registerFormSubmitAction(type, can) {
     type,
     can,
     sideEffect: true,
-    proof: "none",
+    proof: { fields: ["submissionId"] },
     done: doneWhenCompleted,
     defaultRequiresConfirmation: false,
     requiredCapability: "flow/execute",
@@ -3662,7 +4658,11 @@ function registerFormSubmitAction(type, can) {
     },
     outputSchema: [
       { path: "form.answers", displayName: "Form Answers JSON", type: "string", description: "JSON stringified form answers, matching form block runtime output." },
-      { path: "answers", displayName: "Form Answers", type: "object", description: "Parsed form answers object for convenience." }
+      { path: "answers", displayName: "Form Answers", type: "object", description: "Parsed form answers object for convenience." },
+      { path: "submissionId", displayName: "Submission ID", type: "string", description: "Stable proof identifier for this submission." },
+      { path: "answersDigest", displayName: "Answers Digest", type: "string", description: "Content digest; safe to place in a Topic receipt." },
+      { path: "submittedAt", displayName: "Submitted At", type: "string" },
+      { path: "submittedBy", displayName: "Submitted By", type: "string" }
     ],
     events: [
       {
@@ -3673,15 +4673,22 @@ function registerFormSubmitAction(type, can) {
         pendingDisplayFields: ["answers"]
       }
     ],
-    run: async (inputs) => {
+    run: async (inputs, ctx) => {
       const answers = normalizeAnswers(inputs.answers ?? inputs.form?.answers);
       const answersJson = JSON.stringify(answers);
+      const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const answersDigest = sha256Digest(answers);
+      const submissionId = sha256Digest({ type, flowId: ctx.flowId, sessionRunId: ctx.sessionRunId || "", nodeId: ctx.nodeId, submittedAt, answersDigest });
       return {
         output: {
           form: {
             answers: answersJson
           },
-          answers
+          answers,
+          submissionId,
+          answersDigest,
+          submittedAt,
+          submittedBy: ctx.actorDid
         },
         events: [{ name: "form.submitted", payload: { answers } }]
       };
@@ -3710,20 +4717,39 @@ registerAction({
   outputSchema: [
     { path: "runId", displayName: "Session run id", type: "string" },
     { path: "eventId", displayName: "Started event id", type: "string" },
-    { path: "startedAt", displayName: "Started at", type: "number" }
+    { path: "startedAt", displayName: "Started at", type: "number" },
+    { path: "sessionId", displayName: "Session ID", type: "string" },
+    { path: "flowRevision", displayName: "Flow revision", type: "string" },
+    { path: "topicBindingId", displayName: "Topic binding ID", type: "string" }
+  ],
+  events: [
+    {
+      name: "flow.run.started",
+      displayName: "Flow run started",
+      description: "Emitted when a pinned Flow run starts; it does not change Topic status.",
+      payloadSchema: [
+        { path: "runId", displayName: "Run ID", type: "string" },
+        { path: "topicBindingId", displayName: "Topic binding ID", type: "string" }
+      ]
+    }
   ],
   run: async (inputs, ctx) => {
     if (!ctx.services.flowRuns?.start) {
       throw new Error("flowRuns.start handler not available");
     }
-    return {
-      output: await ctx.services.flowRuns.start({
-        actorDid: ctx.actorDid,
-        flowId: ctx.flowId,
-        flowUri: ctx.flowUri,
-        ...typeof inputs.label === "string" && inputs.label ? { label: inputs.label } : {}
-      })
+    const lifecycle = await ctx.services.flowRuns.start({
+      actorDid: ctx.actorDid,
+      flowId: ctx.flowId,
+      flowUri: ctx.flowUri,
+      ...typeof inputs.label === "string" && inputs.label ? { label: inputs.label } : {}
+    });
+    const output = {
+      ...lifecycle,
+      sessionId: lifecycle.runId,
+      flowRevision: ctx.flowRevision || "",
+      topicBindingId: ctx.topic?.bindingId || ""
     };
+    return { output, events: [{ name: "flow.run.started", payload: { runId: lifecycle.runId, topicBindingId: output.topicBindingId } }] };
   }
 });
 registerAction({
@@ -3748,7 +4774,22 @@ registerAction({
     { path: "status", displayName: "Terminal status", type: "string" },
     { path: "eventId", displayName: "Terminal event id", type: "string" },
     { path: "closedAt", displayName: "Closed at", type: "number" },
-    { path: "cancelledAt", displayName: "Cancelled at", type: "number" }
+    { path: "cancelledAt", displayName: "Cancelled at", type: "number" },
+    { path: "runId", displayName: "Session run ID", type: "string" },
+    { path: "flowRevision", displayName: "Flow revision", type: "string" },
+    { path: "topicBindingId", displayName: "Topic binding ID", type: "string" }
+  ],
+  events: [
+    {
+      name: "flow.run.closed",
+      displayName: "Flow run closed",
+      description: "Emitted when the Flow run closes; Topic resolution remains an explicit, separate Action.",
+      payloadSchema: [
+        { path: "runId", displayName: "Run ID", type: "string" },
+        { path: "status", displayName: "Status", type: "string" },
+        { path: "topicBindingId", displayName: "Topic binding ID", type: "string" }
+      ]
+    }
   ],
   run: async (inputs, ctx) => {
     if (!ctx.sessionRunId) {
@@ -3758,24 +4799,30 @@ registerAction({
       throw new Error("flowRuns lifecycle handler not available");
     }
     if (inputs.cancel === true) {
-      return {
-        output: await ctx.services.flowRuns.cancel({
-          actorDid: ctx.actorDid,
-          flowId: ctx.flowId,
-          flowUri: ctx.flowUri,
-          runId: ctx.sessionRunId,
-          ...typeof inputs.reason === "string" && inputs.reason ? { reason: inputs.reason } : {}
-        })
-      };
-    }
-    return {
-      output: await ctx.services.flowRuns.close({
+      const lifecycle2 = await ctx.services.flowRuns.cancel({
         actorDid: ctx.actorDid,
         flowId: ctx.flowId,
         flowUri: ctx.flowUri,
         runId: ctx.sessionRunId,
-        allowIncomplete: inputs.allowIncomplete === true
-      })
+        ...typeof inputs.reason === "string" && inputs.reason ? { reason: inputs.reason } : {}
+      });
+      const output2 = { ...lifecycle2, runId: ctx.sessionRunId, flowRevision: ctx.flowRevision || "", topicBindingId: ctx.topic?.bindingId || "" };
+      return {
+        output: output2,
+        events: [{ name: "flow.run.closed", payload: { runId: ctx.sessionRunId, status: lifecycle2.status, topicBindingId: output2.topicBindingId } }]
+      };
+    }
+    const lifecycle = await ctx.services.flowRuns.close({
+      actorDid: ctx.actorDid,
+      flowId: ctx.flowId,
+      flowUri: ctx.flowUri,
+      runId: ctx.sessionRunId,
+      allowIncomplete: inputs.allowIncomplete === true
+    });
+    const output = { ...lifecycle, runId: ctx.sessionRunId, flowRevision: ctx.flowRevision || "", topicBindingId: ctx.topic?.bindingId || "" };
+    return {
+      output,
+      events: [{ name: "flow.run.closed", payload: { runId: ctx.sessionRunId, status: lifecycle.status, topicBindingId: output.topicBindingId } }]
     };
   }
 });
@@ -3804,6 +4851,10 @@ registerAction({
       replyTo: { type: "string", description: "Reply-to address." }
     }
   },
+  outputSchema: [
+    { path: "messageId", displayName: "Message ID", type: "string", description: "Provider or host notification identifier." },
+    { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp supplied by the provider or host." }
+  ],
   run: async (inputs, ctx) => {
     if (!ctx.services.notify) {
       throw new Error("Notification service not configured");
@@ -4457,6 +5508,22 @@ registerAction({
     };
     return {
       output,
+      topicRecords: ctx.topic ? [
+        {
+          type: "org.ixo.topic.claim-submission",
+          id: sha256Digest({ topicId: ctx.topic.topicId, collectionId, claimId }),
+          version: 1,
+          value: {
+            claimId,
+            collectionId,
+            deedDid,
+            submittedByDid,
+            submittedAt,
+            transactionHash,
+            submissionDigest: sha256Digest(surveyAnswers)
+          }
+        }
+      ] : void 0,
       events: [
         {
           name: "submitted",
@@ -4811,7 +5878,7 @@ registerAction({
       const flowId = String(ctx.flowId || ctx.flowUri || "flow");
       const claimSnapshot = inputs.claimSnapshot && typeof inputs.claimSnapshot === "object" && !Array.isArray(inputs.claimSnapshot) ? inputs.claimSnapshot : void 0;
       const surveyQuestions = Array.isArray(claimSnapshot?.surveyQuestions) ? claimSnapshot.surveyQuestions : Array.isArray(inputs?.surveyAnswersSchema) ? inputs.surveyAnswersSchema : [];
-      const idempotencyKey = buildXeroInvoiceWorkKey({ flowId, evaluationBlockId: ctx.nodeId, claimId });
+      const idempotencyKey2 = buildXeroInvoiceWorkKey({ flowId, evaluationBlockId: ctx.nodeId, claimId });
       const originalPayload = {
         claim: { claimId, collectionId, deedDid },
         surveyQuestions,
@@ -4827,11 +5894,11 @@ registerAction({
         invoiceDefaults: buildXeroInvoiceDefaults(inputs.xeroInvoiceDefaults)
       };
       upsertXeroWorkItemForEditor(ctx.editor, {
-        id: idempotencyKey,
+        id: idempotencyKey2,
         kind: "invoice.create",
         status: "pending",
         assignedBlockId: ctx.nodeId,
-        idempotencyKey,
+        idempotencyKey: idempotencyKey2,
         source: {
           claimId,
           evaluationBlockId: ctx.nodeId,
@@ -4871,6 +5938,25 @@ registerAction({
     };
     return {
       output,
+      topicRecords: ctx.topic ? [
+        {
+          type: "org.ixo.topic.claim-evaluation",
+          id: sha256Digest({ topicId: ctx.topic.topicId, collectionId, claimId, evaluatedAt, decision }),
+          version: 1,
+          value: {
+            claimId,
+            collectionId,
+            deedDid,
+            decision,
+            evaluatedByDid,
+            evaluatedAt,
+            verificationProof,
+            transactionHash,
+            evidenceDigest: sha256Digest(surveyAnswers)
+          },
+          evidenceReferences: verificationProof ? [verificationProof] : []
+        }
+      ] : void 0,
       events: [{ name: eventName, payload: eventPayload }]
     };
   }
@@ -4953,7 +6039,23 @@ registerAction({
         proposalContractAddress: proposalContractAddress || "",
         coreAddress,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
+      },
+      topicRecords: ctx.topic ? [
+        {
+          type: "org.ixo.topic.proposal-receipt",
+          id: sha256Digest({ topicId: ctx.topic.topicId, proposalContractAddress, proposalId }),
+          version: 1,
+          value: {
+            event: "created",
+            proposalId: String(proposalId),
+            proposalContractAddress: proposalContractAddress || "",
+            coreAddress,
+            title,
+            descriptionDigest: sha256Digest(description),
+            status: "open"
+          }
+        }
+      ] : void 0
     };
   }
 });
@@ -5008,13 +6110,30 @@ registerAction({
       rationale: rationale || void 0,
       proposalContractAddress
     });
+    const votedAt = (/* @__PURE__ */ new Date()).toISOString();
     return {
       output: {
         vote,
         rationale: rationale || "",
         proposalId: String(proposalId),
-        votedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
+        votedAt
+      },
+      topicRecords: ctx.topic ? [
+        {
+          type: "org.ixo.topic.proposal-receipt",
+          id: sha256Digest({ topicId: ctx.topic.topicId, proposalContractAddress, proposalId, actorDid: ctx.actorDid, votedAt }),
+          version: 1,
+          value: {
+            event: "vote-cast",
+            proposalId: String(proposalId),
+            proposalContractAddress,
+            vote,
+            rationaleDigest: sha256Digest(rationale),
+            actorDid: ctx.actorDid,
+            votedAt
+          }
+        }
+      ] : void 0
     };
   }
 });
@@ -6826,29 +7945,46 @@ registerAction({
 
 // src/core/lib/actionRegistry/actions/oracle.ts
 registerAction({
-  type: "oracle",
-  can: "oracle/query",
-  sideEffect: false,
-  proof: "none",
+  type: "qi/oracle.invoke",
+  can: "oracle/invoke",
+  sideEffect: true,
+  proof: { fields: ["resultDigest"] },
   done: doneWhenCompleted,
   defaultRequiresConfirmation: false,
   inputSchema: {
     type: "object",
     required: ["prompt"],
     properties: {
-      prompt: { type: "string", description: "The prompt text sent to the companion." }
+      prompt: { type: "string", description: "The prompt text sent to the Agent." }
     }
   },
-  outputSchema: [{ path: "prompt", displayName: "Prompt", type: "string", description: "The prompt sent to the companion" }],
+  sensitiveInputPaths: ["prompt"],
+  sensitiveOutputPaths: ["result"],
+  outputSchema: [
+    { path: "prompt", displayName: "Prompt", type: "string", description: "Legacy Flow-timeline echo; redacted from Topic receipts." },
+    { path: "sessionId", displayName: "Session ID", type: "string", description: "Private Oracle session identifier." },
+    { path: "result", displayName: "Result", type: "object", description: "Full result retained in the Flow timeline." },
+    { path: "resultDigest", displayName: "Result Digest", type: "string", description: "Content digest safe for a Topic receipt." },
+    { path: "evidenceDigest", displayName: "Evidence Digest", type: "string", description: "Digest of evidence references returned by the Oracle." }
+  ],
   run: async (inputs, ctx) => {
     const prompt = String(inputs.prompt || "").trim();
     if (!prompt) throw new Error("prompt is required");
     if (!ctx.handlers?.askCompanion) {
       throw new Error("askCompanion handler is not available");
     }
-    await ctx.handlers.askCompanion(prompt);
+    const raw = await ctx.handlers.askCompanion(prompt);
+    const envelope = raw && typeof raw === "object" ? raw : { result: raw };
+    const result = envelope.result ?? envelope.response ?? envelope.message ?? raw ?? null;
+    const evidence = Array.isArray(envelope.evidenceReferences) ? envelope.evidenceReferences : Array.isArray(envelope.evidence) ? envelope.evidence : [];
     return {
-      output: { prompt }
+      output: {
+        prompt,
+        sessionId: String(envelope.sessionId ?? envelope.runId ?? ""),
+        result,
+        resultDigest: sha256Digest(result),
+        evidenceDigest: sha256Digest(evidence)
+      }
     };
   }
 });
@@ -6984,6 +8120,7 @@ registerAction({
 });
 
 // src/core/lib/actionRegistry/actions/walletFund.ts
+var DEFAULT_DENOM = "uixo";
 registerAction({
   type: "qi/wallet.fund",
   can: "wallet/fund",
@@ -6996,20 +8133,37 @@ registerAction({
     required: ["address"],
     properties: {
       address: { type: "string", description: "The IXO wallet address to fund." },
-      amount: { type: "number", description: "Funding amount in base units (defaults to 250000)." }
+      amount: { type: "number", description: "Funding amount in the denom\u2019s base units (defaults to 250000)." },
+      denom: { type: "string", description: "Base denom to send, e.g. uixo. Defaults to uixo." },
+      fromAddress: {
+        type: "string",
+        description: "Wallet the tokens leave. Defaults to the signed-in user\u2019s wallet; any other address must be one they can act on."
+      }
     }
   },
-  outputSchema: [{ path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" }],
+  outputSchema: [
+    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" },
+    { path: "denom", displayName: "Denom", type: "string", description: "The base denom that was sent" },
+    { path: "amount", displayName: "Amount", type: "string", description: "The amount sent, in the denom\u2019s base units" },
+    { path: "fromAddress", displayName: "From Address", type: "string", description: "The wallet the tokens left (blank when the signer\u2019s own wallet)" }
+  ],
   run: async (inputs, ctx) => {
     if (!ctx.services.oracle?.fundWallet) {
       throw new Error("oracle.fundWallet handler not available");
     }
     if (!inputs.address) throw new Error("address is required");
+    const denom = String(inputs.denom || "").trim() || DEFAULT_DENOM;
+    const amount = Number(inputs.amount) || 25e4;
+    if (!Number.isFinite(amount) || amount <= 0) throw new Error("amount must be greater than 0");
+    if (!Number.isInteger(amount)) throw new Error(`amount must be a whole number of ${denom} base units`);
+    const fromAddress = String(inputs.fromAddress || "").trim();
     const result = await ctx.services.oracle.fundWallet({
       address: inputs.address,
-      amount: inputs.amount || 25e4
+      amount,
+      denom,
+      ...fromAddress ? { fromAddress } : {}
     });
-    return { output: result };
+    return { output: { ...result, denom, amount: String(amount), fromAddress } };
   }
 });
 
@@ -7025,7 +8179,12 @@ registerAction({
     type: "object",
     required: [],
     properties: {
-      amount: { type: "number", description: "Funding amount in base units for the generated wallet (defaults to 250000)." }
+      amount: { type: "number", description: "Funding amount in base units for the generated wallet (defaults to 250000)." },
+      denom: { type: "string", description: "Base denom to send, e.g. uixo. Defaults to uixo." },
+      fromAddress: {
+        type: "string",
+        description: "Wallet the funding leaves. Defaults to the signed-in user\u2019s wallet; any other address must be one they can act on."
+      }
     }
   },
   outputSchema: [
@@ -7033,7 +8192,8 @@ registerAction({
     { path: "did", displayName: "DID", type: "string", description: "The DID derived from the wallet address" },
     { path: "pubKey", displayName: "Public Key", type: "string", description: "The secp256k1 public key (hex)" },
     { path: "mnemonic", displayName: "Mnemonic", type: "string", description: "The BIP39 mnemonic seed phrase" },
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" }
+    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" },
+    { path: "denom", displayName: "Denom", type: "string", description: "The base denom that was sent" }
   ],
   run: async (inputs, ctx) => {
     if (!ctx.services.oracle?.generateWallet) {
@@ -7046,9 +8206,13 @@ registerAction({
     if (!walletResult?.address) {
       throw new Error("generateWallet did not return an address");
     }
+    const denom = String(inputs.denom || "").trim() || "uixo";
+    const fromAddress = String(inputs.fromAddress || "").trim();
     const fundResult = await ctx.services.oracle.fundWallet({
       address: walletResult.address,
-      amount: inputs.amount || 25e4
+      amount: inputs.amount || 25e4,
+      denom,
+      ...fromAddress ? { fromAddress } : {}
     });
     if (!fundResult?.transactionHash) {
       throw new Error("fundWallet did not return a transactionHash");
@@ -7059,7 +8223,8 @@ registerAction({
         did: walletResult.did,
         pubKey: walletResult.pubKey,
         mnemonic: walletResult.mnemonic,
-        transactionHash: fundResult.transactionHash
+        transactionHash: fundResult.transactionHash,
+        denom
       }
     };
   }
@@ -8105,14 +9270,6 @@ var COLLECTION_CREATED_EVENT = {
   pendingDisplayFields: ["collectionId", "entity"]
 };
 
-// src/core/lib/actionRegistry/types.ts
-var CollectionStateEnum = /* @__PURE__ */ ((CollectionStateEnum2) => {
-  CollectionStateEnum2[CollectionStateEnum2["OPEN"] = 0] = "OPEN";
-  CollectionStateEnum2[CollectionStateEnum2["PAUSED"] = 1] = "PAUSED";
-  CollectionStateEnum2[CollectionStateEnum2["CLOSED"] = 2] = "CLOSED";
-  return CollectionStateEnum2;
-})(CollectionStateEnum || {});
-
 // src/core/lib/actionRegistry/actions/collection/collection.ts
 function normalizeQuota(quota) {
   if (quota === void 0 || quota === null) return void 0;
@@ -9014,6 +10171,7 @@ async function runEvalRegister(inputs, ctx) {
   const allowAiChecks = inputs.allowAiChecks !== false;
   const allowImageChecks = allowAiChecks && inputs.allowImageChecks !== false;
   const allowChainEvaluation = inputs.allowChainEvaluation !== false;
+  const allowZeroPayoutApprovals = inputs.allowZeroPayoutApprovals === true;
   if (!collectionId) throw new Error("collectionId is required");
   if (!deedDid) throw new Error("deedDid (entity/deed DID) is required");
   if (!ownerDid) throw new Error("ownerDid is required (pass it explicitly, or run as the collection owner)");
@@ -9052,7 +10210,7 @@ async function runEvalRegister(inputs, ctx) {
     // (see above), and a host that copies `params` field-by-field would otherwise forward an
     // explicit `undefined` as the erasing empty value.
     ...description !== void 0 ? { description } : {},
-    settings: { allowAiChecks, allowImageChecks, allowChainEvaluation }
+    settings: { allowAiChecks, allowImageChecks, allowChainEvaluation, allowZeroPayoutApprovals }
   });
   const registrationId = String(registration?.id || "").trim();
   if (!registrationId) {
@@ -9125,8 +10283,12 @@ function canonicalJson(value) {
   throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
 }
 
+// src/core/lib/actionRegistry/actions/evalRubric/pathGrammar.ts
+var FORM_SEGMENT = "[A-Za-z0-9_-]+(?::[A-Za-z0-9_-]+)?";
+
 // src/core/lib/actionRegistry/actions/evalRubric/fieldCatalog.ts
-var SEGMENT = /^[A-Za-z0-9_-]+$/;
+var SEGMENT = new RegExp(`^${FORM_SEGMENT}$`);
+var NAME_PATH = new RegExp(`^${FORM_SEGMENT}(?:\\.${FORM_SEGMENT})*$`);
 function scalarKind(type, inputType) {
   switch (type) {
     case "text":
@@ -9209,7 +10371,7 @@ function extractRubricFieldCatalog(surveyTemplate, proof = "") {
       }
       const name = typeof el.name === "string" ? el.name.trim() : "";
       const type = typeof el.type === "string" ? el.type : "";
-      if (!name || !SEGMENT.test(name) || seen2.has(name) || type === "html" || type === "expression") continue;
+      if (!name || !NAME_PATH.test(name) || seen2.has(name) || type === "html" || type === "expression") continue;
       const field = extractQuestion(el, name, type);
       if (!field) continue;
       seen2.add(name);
@@ -9305,14 +10467,15 @@ function titleOf(el) {
   return title || humanize2(typeof el.name === "string" ? el.name : "");
 }
 function humanize2(name) {
-  return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const bare = name.split(".").map((seg) => seg.includes(":") ? seg.split(":").pop() : seg).join(".");
+  return bare.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 function stripHtml2(s) {
   return s.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
 }
 
 // src/core/lib/actionRegistry/actions/evalRubric/schemaGate.ts
-import Ajv2020 from "ajv/dist/2020.js";
+import Ajv20202 from "ajv/dist/2020.js";
 
 // src/core/lib/actionRegistry/actions/evalRubric/types.ts
 var RUBRIC_CTX_TOKENS = [
@@ -9396,7 +10559,7 @@ async function getValidator(fetchSchema, evalEngineUrl) {
   if (compiledValidator) return compiledValidator;
   const schema = await fetchSchema(evalEngineUrl);
   if (!schema || typeof schema !== "object") throw new Error("the rules service returned no schema");
-  const validate = new Ajv2020({ allErrors: true, strict: false }).compile(schema);
+  const validate = new Ajv20202({ allErrors: true, strict: false }).compile(schema);
   compiledValidator = validate;
   return validate;
 }
@@ -9494,7 +10657,7 @@ var ExpressionSyntaxError = class extends Error {
 };
 var IDENT = /[A-Za-z_][A-Za-z0-9_]*/y;
 var NUMBER = /(?:\d+\.?\d*|\.\d+)/y;
-var FIELD_REF = /\$[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+|\[\*\])*/y;
+var FIELD_REF = new RegExp(`\\$${FORM_SEGMENT}(?:\\.${FORM_SEGMENT}|\\[\\*\\])*`, "y");
 var SIGIL_REF = /~[A-Za-z_][A-Za-z0-9_]*/y;
 var CTX_REF = /ctx(?:\.[A-Za-z][A-Za-z0-9]*)+/y;
 function parseExpression(src) {
@@ -9657,8 +10820,9 @@ var CTX_TOKEN_KIND = {
   "ctx.submitter.priorApprovedCount": "number",
   "ctx.collection.projectBoundary": "geo"
 };
-var FIELD_REF2 = /^\$[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+|\[\*\])*$/;
-var ROW_REF = /^\.[A-Za-z0-9_-]+$/;
+var FIELD_REF2 = new RegExp(`^\\$${FORM_SEGMENT}(?:\\.${FORM_SEGMENT}|\\[\\*\\])*$`);
+var ROW_REF = new RegExp(`^\\.${FORM_SEGMENT}$`);
+var FIELD_ROOT = new RegExp(`^\\$${FORM_SEGMENT}`);
 var DERIVED_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var EXT_REF = /^ext\.([A-Za-z0-9_-]+)\.(valid|score|reason)$/;
 var AI_REF = /^ai\.([A-Za-z0-9_-]+)\.(valid|reason)$/;
@@ -9690,7 +10854,7 @@ function validateRubric(body, catalog, authoringCatalog) {
       error("RUB_SCHEMA_DRIFT", `'${ref}' no longer exists on the claim form (deleted or renamed since the rules were authored)`, path);
       return void 0;
     }
-    const rootName = /^\$[A-Za-z0-9_-]+/.exec(ref)?.[0] ?? ref;
+    const rootName = FIELD_ROOT.exec(ref)?.[0] ?? ref;
     if (ref !== rootName && fieldIndex.has(rootName)) {
       error("RUB_FIELD_PATH", `'${ref}' does not address a row/column of ${rootName}`, path);
     } else {
@@ -10763,6 +11927,11 @@ registerAction({
       allowAiChecks: { type: "boolean", default: true, description: "Engine setting: allow paid AI checks for this collection." },
       allowImageChecks: { type: "boolean", default: true, description: "Engine setting: allow fake-photo detection (needs AI checks on)." },
       allowChainEvaluation: { type: "boolean", default: true, description: "Engine setting: submit the decision on chain (releases payment); makes adminAddress required." },
+      allowZeroPayoutApprovals: {
+        type: "boolean",
+        default: false,
+        description: "Engine setting: approve on chain even when the approval pays nothing (attestation-only collections). Opt-in \u2014 otherwise such approvals wait for the owner."
+      },
       evaluateMaxAmount: { type: "array", description: "Per-claim payout cap on the evaluate grant, base-unit coins in the owner's denoms." },
       // ---- rules (qi/eval.rubric) ----
       rubric: {
@@ -10935,6 +12104,27 @@ registerAction({
 });
 
 // src/core/lib/actionRegistry/actions/_shared/delegatedTool.ts
+function delegatedToolInputSchema(schema) {
+  return {
+    type: "object",
+    required: ["connection", ...schema.parameters.required],
+    additionalProperties: false,
+    properties: {
+      connection: {
+        type: "object",
+        required: ["bindingId", "connectedAccountId", "toolkit"],
+        additionalProperties: false,
+        properties: {
+          bindingId: { type: "string", minLength: 1, description: "Opaque, server-side delegated credential binding." },
+          connectedAccountId: { type: "string" },
+          toolkit: { type: "string" },
+          label: { type: ["string", "null"] }
+        }
+      },
+      ...schema.parameters.properties
+    }
+  };
+}
 function parseBoundConnection(raw) {
   if (!raw || typeof raw !== "object") return null;
   const c = raw;
@@ -11021,7 +12211,10 @@ async function executeDelegatedTool(ctx, opts) {
     }
     throw new Error(result.error || `${opts.toolkitLabel} action failed.`);
   }
-  return result.data ?? {};
+  return {
+    data: result.data ?? {},
+    providerInvocationReceipt: result.providerInvocationReceipt
+  };
 }
 
 // src/core/lib/actionRegistry/actions/gmail/emailSend.types.ts
@@ -11047,7 +12240,9 @@ var GMAIL_SEND_SCHEMA = {
 var GMAIL_SEND_OUTPUT_SCHEMA = [
   { path: "messageId", displayName: "Message ID", type: "string", description: "Gmail id of the sent message" },
   { path: "threadId", displayName: "Thread ID", type: "string" },
-  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" },
+  { path: "providerReceiptId", displayName: "Provider Receipt ID", type: "string", description: "Signed integration-host invocation receipt identifier" },
+  { path: "providerInvocationReceipt", displayName: "Provider Receipt", type: "object", description: "Signed integration-host invocation receipt" }
 ];
 
 // src/core/lib/actionRegistry/actions/gmail/emailSend.ts
@@ -11062,6 +12257,7 @@ registerAction({
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → send email).
   eligibleForEventTrigger: true,
+  inputSchema: delegatedToolInputSchema(GMAIL_SEND_SCHEMA),
   // Mirrors executeDelegatedTool's gates: the bound connection plus the
   // tool schema's required fields, so orchestrators ask before run() throws.
   getMissingInputs: (inputs) => delegatedToolMissingInputs(GMAIL_SEND_SCHEMA, inputs),
@@ -11081,13 +12277,14 @@ registerAction({
   run: async (inputs, ctx) => {
     const parsed = parseDelegatedToolInputs(inputs);
     const values = fieldValues(parsed);
-    const data = await executeDelegatedTool(ctx, {
+    const execution = await executeDelegatedTool(ctx, {
       connection: parsed.connection,
       schema: GMAIL_SEND_SCHEMA,
       toolSlug: GMAIL_SEND_SLUG,
       values,
       toolkitLabel: "Gmail"
     });
+    const { data, providerInvocationReceipt } = execution;
     const envelope = data.response_data ?? data;
     const messageId = String(envelope.id ?? envelope.messageId ?? "");
     const threadId = String(envelope.threadId ?? "");
@@ -11095,7 +12292,9 @@ registerAction({
       output: {
         messageId,
         threadId,
-        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+        sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+        providerReceiptId: providerInvocationReceipt?.id || "",
+        providerInvocationReceipt
       },
       events: messageId ? [{ name: GMAIL_SENT_EVENT, payload: { messageId, recipient_email: values.recipient_email ?? "" } }] : void 0
     };
@@ -11125,7 +12324,9 @@ var OUTLOOK_SEND_SCHEMA = {
 };
 var OUTLOOK_SEND_OUTPUT_SCHEMA = [
   { path: "messageId", displayName: "Message ID", type: "string" },
-  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" },
+  { path: "providerReceiptId", displayName: "Provider Receipt ID", type: "string", description: "Required signed proof when Outlook returns no message id" },
+  { path: "providerInvocationReceipt", displayName: "Provider Receipt", type: "object", description: "Signed integration-host invocation receipt" }
 ];
 
 // src/core/lib/actionRegistry/actions/outlook/emailSend.ts
@@ -11133,16 +12334,15 @@ 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",
+  // Outlook often returns no message id. The integration host must therefore
+  // return a signed provider invocation receipt for proof of the side effect.
+  proof: { fields: ["messageId", "providerReceiptId"] },
   done: doneWhenCompleted,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → send email).
   eligibleForEventTrigger: true,
+  inputSchema: delegatedToolInputSchema(OUTLOOK_SEND_SCHEMA),
   // Mirrors executeDelegatedTool's gates: the bound connection plus the
   // tool schema's required fields, so orchestrators ask before run() throws.
   getMissingInputs: (inputs) => delegatedToolMissingInputs(OUTLOOK_SEND_SCHEMA, inputs),
@@ -11162,19 +12362,25 @@ registerAction({
   run: async (inputs, ctx) => {
     const parsed = parseDelegatedToolInputs(inputs);
     const values = fieldValues(parsed);
-    const data = await executeDelegatedTool(ctx, {
+    const execution = await executeDelegatedTool(ctx, {
       connection: parsed.connection,
       schema: OUTLOOK_SEND_SCHEMA,
       toolSlug: OUTLOOK_SEND_SLUG,
       values,
       toolkitLabel: "Outlook"
     });
+    const { data, providerInvocationReceipt } = execution;
     const envelope = data.response_data ?? data;
     const messageId = String(envelope.id ?? envelope.messageId ?? "");
+    if (!messageId && !providerInvocationReceipt?.id) {
+      throw new Error("Outlook returned no message id and the integration host returned no signed provider invocation receipt.");
+    }
     return {
       output: {
         messageId,
-        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+        sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+        providerReceiptId: providerInvocationReceipt?.id || "",
+        providerInvocationReceipt
       },
       // Outlook often returns no id, so emit unconditionally.
       events: [{ name: OUTLOOK_SENT_EVENT, payload: { messageId, to_email: values.to_email ?? "" } }]
@@ -11206,7 +12412,9 @@ var SLACK_SEND_SCHEMA = {
 var SLACK_SEND_OUTPUT_SCHEMA = [
   { path: "messageTs", displayName: "Message ts", type: "string" },
   { path: "channel", displayName: "Channel", type: "string" },
-  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" }
+  { path: "sentAt", displayName: "Sent At", type: "string", description: "ISO timestamp when sent" },
+  { path: "providerReceiptId", displayName: "Provider Receipt ID", type: "string", description: "Signed integration-host invocation receipt identifier" },
+  { path: "providerInvocationReceipt", displayName: "Provider Receipt", type: "object", description: "Signed integration-host invocation receipt" }
 ];
 
 // src/core/lib/actionRegistry/actions/slack/messageSend.ts
@@ -11221,6 +12429,7 @@ registerAction({
   requiredCapability: "flow/block/execute",
   // Can be wired to another block's event (e.g. form submitted → post message).
   eligibleForEventTrigger: true,
+  inputSchema: delegatedToolInputSchema(SLACK_SEND_SCHEMA),
   // Mirrors executeDelegatedTool's gates: the bound connection plus the
   // tool schema's required fields, so orchestrators ask before run() throws.
   getMissingInputs: (inputs) => delegatedToolMissingInputs(SLACK_SEND_SCHEMA, inputs),
@@ -11240,13 +12449,14 @@ registerAction({
   run: async (inputs, ctx) => {
     const parsed = parseDelegatedToolInputs(inputs);
     const values = fieldValues(parsed);
-    const data = await executeDelegatedTool(ctx, {
+    const execution = await executeDelegatedTool(ctx, {
       connection: parsed.connection,
       schema: SLACK_SEND_SCHEMA,
       toolSlug: SLACK_SEND_SLUG,
       values,
       toolkitLabel: "Slack"
     });
+    const { data, providerInvocationReceipt } = execution;
     const envelope = data.response_data ?? data;
     const messageTs = String(envelope.ts ?? "");
     const channel = String(envelope.channel ?? values.channel ?? "");
@@ -11254,7 +12464,9 @@ registerAction({
       output: {
         messageTs,
         channel,
-        sentAt: (/* @__PURE__ */ new Date()).toISOString()
+        sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+        providerReceiptId: providerInvocationReceipt?.id || "",
+        providerInvocationReceipt
       },
       events: messageTs ? [{ name: SLACK_SENT_EVENT, payload: { messageTs, channel } }] : void 0
     };
@@ -11287,7 +12499,9 @@ var GOOGLECALENDAR_CREATE_OUTPUT_SCHEMA = [
   { path: "eventId", displayName: "Event ID", type: "string" },
   { path: "htmlLink", displayName: "Event link", type: "string" },
   { path: "summary", displayName: "Summary", type: "string" },
-  { path: "startIso", displayName: "Start", type: "string" }
+  { path: "startIso", displayName: "Start", type: "string" },
+  { path: "providerReceiptId", displayName: "Provider Receipt ID", type: "string", description: "Signed integration-host invocation receipt identifier" },
+  { path: "providerInvocationReceipt", displayName: "Provider Receipt", type: "object", description: "Signed integration-host invocation receipt" }
 ];
 
 // src/core/lib/actionRegistry/actions/googlecalendar/eventCreate.ts
@@ -11301,6 +12515,7 @@ registerAction({
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   eligibleForEventTrigger: true,
+  inputSchema: delegatedToolInputSchema(GOOGLECALENDAR_CREATE_SCHEMA),
   // Mirrors executeDelegatedTool's gates: the bound connection plus the
   // tool schema's required fields, so orchestrators ask before run() throws.
   getMissingInputs: (inputs) => delegatedToolMissingInputs(GOOGLECALENDAR_CREATE_SCHEMA, inputs),
@@ -11321,13 +12536,14 @@ registerAction({
   run: async (inputs, ctx) => {
     const parsed = parseDelegatedToolInputs(inputs);
     const values = fieldValues(parsed);
-    const data = await executeDelegatedTool(ctx, {
+    const execution = await executeDelegatedTool(ctx, {
       connection: parsed.connection,
       schema: GOOGLECALENDAR_CREATE_SCHEMA,
       toolSlug: GOOGLECALENDAR_CREATE_SLUG,
       values,
       toolkitLabel: "Google Calendar"
     });
+    const { data, providerInvocationReceipt } = execution;
     const envelope = data.response_data ?? data;
     const eventId = String(envelope.id ?? "");
     const htmlLink = String(envelope.htmlLink ?? "");
@@ -11335,12 +12551,774 @@ registerAction({
     const start = envelope.start;
     const startIso = String(start?.dateTime ?? start?.date ?? values.start_datetime ?? "");
     return {
-      output: { eventId, htmlLink, summary, startIso },
+      output: { eventId, htmlLink, summary, startIso, providerReceiptId: providerInvocationReceipt?.id || "", providerInvocationReceipt },
       events: eventId ? [{ name: GOOGLECALENDAR_CREATED_EVENT, payload: { eventId, htmlLink, summary } }] : void 0
     };
   }
 });
 
+// src/core/lib/actionRegistry/actions/topicActions.ts
+var ALL_KINDS2 = ["task", "agent_task", "proposal", "evaluation", "claims", "question", "discussion", "incident"];
+function topicMetadata(supportedBaseKinds, permittedTopicRecordTypes, requiredTopicAbilities, relevance = "recommended", sensitiveInputPaths = [], sensitiveOutputPaths = []) {
+  const semanticRecordTypes = getTopicSemanticRecordDefinitions(permittedTopicRecordTypes);
+  if (semanticRecordTypes.length !== permittedTopicRecordTypes.length) {
+    throw new Error(`Topic Action metadata names a semantic record type without a complete definition`);
+  }
+  return {
+    supportedBaseKinds,
+    relevance,
+    writeBackMode: permittedTopicRecordTypes.length > 0 ? "semantic-record" : "receipt-only",
+    semanticRecordTypes,
+    permittedTopicRecordTypes: semanticRecordTypes.map((definition) => definition.type),
+    lifecycleEffect: "none",
+    requiredTopicAbilities,
+    redactionPolicy: { mode: "paths", sensitiveInputPaths, sensitiveOutputPaths }
+  };
+}
+function requiredString(value, name) {
+  const normalized = String(value || "").trim();
+  if (!normalized) throw new Error(`${name} is required`);
+  return normalized;
+}
+function requiredArray(value, name) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error(`${name} must be an array of strings`);
+  return value.map(String);
+}
+function topicContext(ctx) {
+  if (!ctx.topic) throw new Error("This Action requires a revision-bound Topic execution context");
+  return ctx.topic;
+}
+function topicService(ctx) {
+  topicContext(ctx);
+  if (!ctx.services.topic) throw new Error("The host did not grant the capability-checked Topic service");
+  return ctx.services.topic;
+}
+function idempotencyKey(actionType, inputs, ctx) {
+  const explicit = String(inputs.idempotencyKey || "").trim();
+  if (explicit) return explicit;
+  const topic = topicContext(ctx);
+  return sha256Digest({ actionType, topicId: topic.topicId, topicRevision: topic.topicRevision, requestId: topic.requestId, inputs });
+}
+function semanticRecord(type, value, ctx) {
+  const topic = topicContext(ctx);
+  const digest2 = sha256Digest(value);
+  return {
+    digest: digest2,
+    record: {
+      type,
+      id: sha256Digest({ type, topicId: topic.topicId, requestId: topic.requestId, digest: digest2 }),
+      version: 1,
+      value,
+      evidenceReferences: Array.isArray(value.evidenceReferences) ? value.evidenceReferences : void 0
+    }
+  };
+}
+function registerTopicOperation(spec) {
+  registerAction({
+    type: spec.type,
+    can: spec.can,
+    sideEffect: true,
+    proof: { fields: ["operationId"] },
+    done: doneWhenCompleted,
+    defaultRequiresConfirmation: spec.confirmation === true,
+    requiredCapability: "flow/block/execute",
+    executionOwner: spec.owner || "agent",
+    hiddenFromAuthoring: spec.hidden,
+    riskTier: spec.confirmation ? "high" : "medium",
+    requiredServices: ["topic"],
+    topic: topicMetadata(spec.kinds || ALL_KINDS2, [], [spec.ability]),
+    inputSchema: spec.inputSchema,
+    outputSchema: [
+      { path: "operationId", displayName: "Topic operation ID", type: "string" },
+      { path: "topicRevision", displayName: "Topic revision", type: "string" },
+      { path: "proofReference", displayName: "Operation proof", type: "string" }
+    ],
+    run: async (inputs, ctx) => {
+      const service = topicService(ctx);
+      const payload = await spec.buildPayload(inputs, ctx);
+      return {
+        output: await service.appendOperation({
+          context: topicContext(ctx),
+          actorDid: ctx.actorDid,
+          operationType: spec.operationType,
+          payload,
+          idempotencyKey: idempotencyKey(spec.type, inputs, ctx)
+        })
+      };
+    }
+  });
+}
+registerTopicOperation({
+  type: "qi/topic.flow.bind",
+  can: "topic/flow.bind",
+  operationType: "bind-flow",
+  confirmation: true,
+  owner: "human",
+  ability: "topic/bind-flow",
+  inputSchema: {
+    type: "object",
+    required: ["flowUri", "flowRevision", "flowDigest", "actionManifestDigest", "controllerDid", "role", "startPolicy", "triggerPolicy", "receiptPolicy"],
+    additionalProperties: false,
+    properties: {
+      bindingId: { type: "string" },
+      flowUri: { type: "string" },
+      flowRevision: { type: "string" },
+      flowDigest: { type: "string", pattern: "^sha256:" },
+      actionManifestDigest: { type: "string", pattern: "^sha256:" },
+      controllerDid: { type: "string", pattern: "^did:" },
+      role: { type: "string", enum: ["primary", "supporting"] },
+      startPolicy: { type: "string", enum: ["manual", "on-topic-active", "scheduled", "event"] },
+      triggerPolicy: { type: "object" },
+      receiptPolicy: { type: "string", enum: ["all", "terminal"] },
+      capabilityReferences: { type: "array", minItems: 2, uniqueItems: true, items: { type: "string" } },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs, ctx) => {
+    const topic = topicContext(ctx);
+    return {
+      binding: {
+        version: 1,
+        bindingId: String(inputs.bindingId || sha256Digest({ topicId: topic.topicId, flowUri: inputs.flowUri, flowRevision: inputs.flowRevision })),
+        topicId: topic.topicId,
+        flowUri: requiredString(inputs.flowUri, "flowUri"),
+        flowRevision: requiredString(inputs.flowRevision, "flowRevision"),
+        flowDigest: requiredString(inputs.flowDigest, "flowDigest"),
+        actionManifestDigest: requiredString(inputs.actionManifestDigest, "actionManifestDigest"),
+        controllerDid: requiredString(inputs.controllerDid, "controllerDid"),
+        role: requiredString(inputs.role, "role"),
+        startPolicy: requiredString(inputs.startPolicy, "startPolicy"),
+        triggerPolicy: inputs.triggerPolicy || {},
+        receiptPolicy: requiredString(inputs.receiptPolicy, "receiptPolicy"),
+        status: "active",
+        capability: topic.topicCapabilityReference,
+        capabilityReferences: Array.isArray(inputs.capabilityReferences) ? inputs.capabilityReferences.map(String) : [],
+        createdBy: ctx.actorDid,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+});
+registerTopicOperation({
+  type: "qi/topic.flow.unbind",
+  can: "topic/flow.unbind",
+  operationType: "unbind-flow",
+  confirmation: true,
+  owner: "human",
+  ability: "topic/bind-flow",
+  inputSchema: {
+    type: "object",
+    required: ["bindingId"],
+    additionalProperties: false,
+    properties: { bindingId: { type: "string" }, reason: { type: "string" }, idempotencyKey: { type: "string" } }
+  },
+  buildPayload: (inputs) => ({ bindingId: requiredString(inputs.bindingId, "bindingId"), reason: String(inputs.reason || "") })
+});
+registerTopicOperation({
+  type: "qi/topic.action.request",
+  can: "topic/action.request",
+  operationType: "request-action",
+  ability: "topic/request-action",
+  inputSchema: {
+    type: "object",
+    required: ["actionType", "actionContractDigest", "inputDigest"],
+    additionalProperties: false,
+    properties: {
+      actionType: { type: "string" },
+      actionContractDigest: { type: "string", pattern: "^sha256:" },
+      inputDigest: { type: "string", pattern: "^sha256:" },
+      inputReference: { type: "string" },
+      requestId: { type: "string" },
+      safeInputSummary: { type: "object" },
+      executorPreference: { type: "string", enum: ["qi-flow", "qiforge", "mcp"] },
+      bindingId: { type: "string" },
+      confirmationPolicy: { type: "string", enum: ["inherit", "required"] },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs, ctx) => {
+    const actionType = requiredString(inputs.actionType, "actionType");
+    if (actionType === "qi/topic.action.request") throw new Error("A Topic Action request cannot recursively request itself");
+    const target = getAction(actionType);
+    if (!target) throw new Error(`Unknown Action type '${actionType}'`);
+    const manifestEntry = generateActionManifest().actions.find((entry) => entry.type === target.type);
+    const suppliedDigest = requiredString(inputs.actionContractDigest, "actionContractDigest");
+    if (!manifestEntry || manifestEntry.contractDigest !== suppliedDigest) throw new Error("Action contract digest does not match the live registry");
+    const kind = topicContext(ctx).kind;
+    const baseKind = kind.source === "standard" ? kind.kind : kind.baseKind;
+    if (!target.topic?.supportedBaseKinds.includes(baseKind)) throw new Error(`Action '${actionType}' does not support Topic base Kind '${baseKind}'`);
+    const topic = topicContext(ctx);
+    const inputDigest = requiredString(inputs.inputDigest, "inputDigest");
+    const derived = (purpose) => sha256Digest({ purpose, parentRequestId: topic.requestId, topicId: topic.topicId, actionType: target.type, inputDigest });
+    return {
+      request: {
+        version: 1,
+        requestId: String(inputs.requestId || derived("topic-action-request")),
+        topicId: topic.topicId,
+        topicRevision: topic.topicRevision,
+        actionType: target.type,
+        actionContractDigest: suppliedDigest,
+        executor: inputs.executorPreference || "qi-flow",
+        inputs: { digest: inputDigest, ...inputs.inputReference ? { ref: String(inputs.inputReference) } : {} },
+        requestedBy: ctx.actorDid,
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        idempotencyKey: String(inputs.idempotencyKey || derived("topic-action-idempotency")),
+        confirmation: target.defaultRequiresConfirmation || inputs.confirmationPolicy === "required" ? "required" : topic.confirmationReference ? "confirmed" : "not-required",
+        ...inputs.bindingId ? { flowBindingId: String(inputs.bindingId) } : {},
+        capability: topic.topicCapabilityReference
+      }
+    };
+  }
+});
+registerTopicOperation({
+  type: "qi/topic.action.receipt.record",
+  can: "topic/action.receipt.record",
+  operationType: "record-action-receipt",
+  ability: "topic/record-action",
+  hidden: true,
+  inputSchema: {
+    type: "object",
+    required: ["receipt"],
+    additionalProperties: false,
+    properties: { receipt: { type: "object" }, idempotencyKey: { type: "string" } }
+  },
+  buildPayload: (inputs, ctx) => {
+    if (!inputs.receipt || typeof inputs.receipt !== "object" || Array.isArray(inputs.receipt)) throw new Error("receipt must be an ActionReceiptV2 object");
+    const receipt = inputs.receipt;
+    if (receipt.topicId !== topicContext(ctx).topicId) throw new Error("Receipt Topic does not match the execution context");
+    if (receipt.version !== 2 || !receipt.signature || !receipt.issuerDid) throw new Error("Receipt requires a v2 issuer signature");
+    const receiptAction = receipt.action;
+    const action = getAction(String(receiptAction?.type || ""));
+    const manifestEntry = action && generateActionManifest().actions.find((entry) => entry.type === action.type);
+    if (!manifestEntry || manifestEntry.contractDigest !== receiptAction?.contractDigest) throw new Error("Receipt Action contract digest does not match the live registry");
+    return { receipt };
+  }
+});
+registerTopicOperation({
+  type: "qi/topic.action.cancel",
+  can: "topic/action.cancel",
+  operationType: "cancel-action",
+  ability: "topic/cancel-action",
+  inputSchema: {
+    type: "object",
+    required: ["requestId", "reason"],
+    additionalProperties: false,
+    properties: { requestId: { type: "string" }, reason: { type: "string" }, idempotencyKey: { type: "string" } }
+  },
+  buildPayload: (inputs) => ({ requestId: requiredString(inputs.requestId, "requestId"), reason: requiredString(inputs.reason, "reason") })
+});
+registerTopicOperation({
+  type: "qi/topic.status.transition",
+  can: "topic/status.transition",
+  operationType: "change-status",
+  confirmation: true,
+  owner: "human",
+  ability: "topic/change-status",
+  inputSchema: {
+    type: "object",
+    required: ["from", "to", "reason"],
+    additionalProperties: false,
+    properties: { from: { type: "string" }, to: { type: "string" }, reason: { type: "string" }, idempotencyKey: { type: "string" } }
+  },
+  buildPayload: async (inputs, ctx) => {
+    const from = requiredString(inputs.from, "from");
+    const to = requiredString(inputs.to, "to");
+    if (to === "resolved") {
+      const topic = topicContext(ctx);
+      const projection = await topicService(ctx).readProjection?.({ topicId: topic.topicId, topicRevision: topic.topicRevision, requestId: topic.requestId });
+      if (!projection) throw new Error("Resolution requires a current Topic projection so completion policy can be verified");
+      const completion = projection.completion;
+      const outcome = projection.outcome;
+      if (completion?.requiresOutcomeRecord === true && !outcome?.outcomeRecordId) throw new Error("Topic policy requires an accepted outcome record before resolution");
+    }
+    return { from, to, reason: requiredString(inputs.reason, "reason") };
+  }
+});
+registerTopicOperation({
+  type: "qi/topic.contract.accept",
+  can: "topic/contract.accept",
+  operationType: "accept-contract",
+  confirmation: true,
+  owner: "human",
+  ability: "topic/accept-contract",
+  inputSchema: {
+    type: "object",
+    required: ["contractRevision", "contractDigest", "confirmationReference"],
+    additionalProperties: false,
+    properties: {
+      contractRevision: { type: "string" },
+      contractDigest: { type: "string", pattern: "^sha256:" },
+      confirmationReference: { type: "string" },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs, ctx) => {
+    const revision = requiredString(inputs.contractRevision, "contractRevision");
+    const digest2 = requiredString(inputs.contractDigest, "contractDigest");
+    if (revision !== topicContext(ctx).contract.revision || digest2 !== topicContext(ctx).contract.digest)
+      throw new Error("Contract acceptance must target the exact effective revision and digest");
+    return { contractRevision: revision, contractDigest: digest2, confirmationReference: requiredString(inputs.confirmationReference, "confirmationReference") };
+  }
+});
+registerTopicOperation({
+  type: "qi/topic.outcome.propose",
+  can: "topic/outcome.propose",
+  operationType: "update-contract",
+  ability: "topic/update-contract",
+  inputSchema: {
+    type: "object",
+    required: ["statement"],
+    additionalProperties: false,
+    properties: { statement: { type: "string" }, evidenceReferences: { type: "array", items: { type: "string" } }, idempotencyKey: { type: "string" } }
+  },
+  buildPayload: (inputs) => ({
+    patch: {
+      outcome: {
+        statement: requiredString(inputs.statement, "statement"),
+        status: "proposed",
+        evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences")
+      }
+    }
+  })
+});
+registerTopicOperation({
+  type: "qi/topic.outcome.confirm",
+  can: "topic/outcome.confirm",
+  operationType: "update-contract",
+  confirmation: true,
+  owner: "human",
+  ability: "topic/update-contract",
+  inputSchema: {
+    type: "object",
+    required: ["proposedOutcomeRecordId", "confirmationAuthorityDid", "confirmationReference"],
+    additionalProperties: false,
+    properties: {
+      proposedOutcomeRecordId: { type: "string" },
+      confirmationAuthorityDid: { type: "string", pattern: "^did:" },
+      confirmationReference: { type: "string" },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs) => ({
+    patch: {
+      outcome: {
+        status: "achieved",
+        outcomeRecordId: requiredString(inputs.proposedOutcomeRecordId, "proposedOutcomeRecordId"),
+        confirmedBy: requiredString(inputs.confirmationAuthorityDid, "confirmationAuthorityDid"),
+        confirmationReference: requiredString(inputs.confirmationReference, "confirmationReference")
+      }
+    }
+  })
+});
+registerTopicOperation({
+  type: "qi/topic.decision.record",
+  can: "topic/decision.record",
+  operationType: "record-decision",
+  ability: "topic/record-decision",
+  inputSchema: {
+    type: "object",
+    required: ["decision", "authorityDid", "rationale"],
+    additionalProperties: false,
+    properties: {
+      decision: { type: "string" },
+      authorityDid: { type: "string", pattern: "^did:" },
+      rationale: { type: "string" },
+      alternatives: { type: "array", items: { type: "string" } },
+      receiptReferences: { type: "array", items: { type: "string" } },
+      evidenceReferences: { type: "array", items: { type: "string" } },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs) => ({
+    decision: requiredString(inputs.decision, "decision"),
+    authorityDid: requiredString(inputs.authorityDid, "authorityDid"),
+    rationale: requiredString(inputs.rationale, "rationale"),
+    alternatives: requiredArray(inputs.alternatives || [], "alternatives"),
+    receiptReferences: requiredArray(inputs.receiptReferences || [], "receiptReferences"),
+    evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences")
+  })
+});
+registerTopicOperation({
+  type: "qi/topic.context.link",
+  can: "topic/context.link",
+  operationType: "link-context",
+  ability: "topic/link-context",
+  inputSchema: {
+    type: "object",
+    required: ["contextType", "id"],
+    additionalProperties: false,
+    properties: {
+      contextType: { type: "string", enum: ["ixo.resource", "ixo.flow", "matrix.conversation", "ixo.entity", "ixo.service"] },
+      id: { type: "string" },
+      label: { type: "string" },
+      reference: { type: "string" },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs) => ({
+    type: requiredString(inputs.contextType, "contextType"),
+    id: requiredString(inputs.id, "id"),
+    label: String(inputs.label || ""),
+    reference: String(inputs.reference || "")
+  })
+});
+registerTopicOperation({
+  type: "qi/topic.file.attach-reference",
+  can: "topic/file.attach-reference",
+  operationType: "attach-files",
+  ability: "topic/attach-files",
+  inputSchema: {
+    type: "object",
+    required: ["resource", "fileId", "version", "cid", "contentHash", "path", "name", "mimeType", "size"],
+    additionalProperties: false,
+    properties: {
+      resource: { type: "string" },
+      fileId: { type: "string" },
+      version: { type: "number" },
+      cid: { type: "string" },
+      contentHash: { type: "string" },
+      path: { type: "string" },
+      name: { type: "string" },
+      mimeType: { type: "string" },
+      size: { type: "number" },
+      idempotencyKey: { type: "string" }
+    }
+  },
+  buildPayload: (inputs) => {
+    if ("bytes" in inputs || "content" in inputs || "capability" in inputs)
+      throw new Error("Topic file Actions accept pinned references only; bytes and access grants are forbidden");
+    return {
+      attachments: [
+        {
+          provider: "ixo.vfs",
+          resource: inputs.resource,
+          fileId: inputs.fileId,
+          version: inputs.version,
+          cid: inputs.cid,
+          contentHash: inputs.contentHash,
+          path: inputs.path,
+          name: inputs.name,
+          mimeType: inputs.mimeType,
+          size: inputs.size
+        }
+      ]
+    };
+  }
+});
+function registerSemanticAction(spec) {
+  registerAction({
+    type: spec.type,
+    can: spec.can,
+    sideEffect: true,
+    proof: { fields: ["recordDigest"] },
+    done: doneWhenCompleted,
+    defaultRequiresConfirmation: spec.confirmation === true,
+    requiredCapability: "flow/block/execute",
+    executionOwner: spec.owner || "agent",
+    riskTier: spec.riskTier,
+    requiredServices: spec.requiredServices || ["topic"],
+    sensitiveInputPaths: spec.sensitiveInputPaths,
+    sensitiveOutputPaths: spec.sensitiveOutputPaths,
+    topic: topicMetadata(spec.kinds, [spec.recordType], ["topic/request-action", "topic/record-action"], "recommended", spec.sensitiveInputPaths, spec.sensitiveOutputPaths),
+    inputSchema: spec.inputSchema,
+    outputSchema: [
+      { path: "recordId", displayName: "Semantic record ID", type: "string" },
+      { path: "recordType", displayName: "Semantic record type", type: "string" },
+      { path: "recordDigest", displayName: "Semantic record digest", type: "string" },
+      { path: "record", displayName: "Semantic record", type: "object" }
+    ],
+    run: async (inputs, ctx) => {
+      topicContext(ctx);
+      const value = await spec.execute(inputs, ctx);
+      const { record, digest: digest2 } = semanticRecord(spec.recordType, value, ctx);
+      return { output: { recordId: record.id, recordType: record.type, recordDigest: digest2, record: value }, topicRecords: [record] };
+    }
+  });
+}
+var WORK_PHASES = {
+  "qi/work.assign": "requested",
+  "qi/work.dispatch": "dispatched",
+  "qi/work.checkpoint": "in_progress",
+  "qi/work.submit": "ready_for_review",
+  "qi/work.accept": "completed"
+};
+for (const [type, phase] of Object.entries(WORK_PHASES)) {
+  registerSemanticAction({
+    type,
+    can: type.replace("qi/", "").replace(".", "/"),
+    kinds: ["task", "discussion", "incident"],
+    recordType: "org.ixo.topic.work-event",
+    confirmation: type === "qi/work.accept",
+    owner: type === "qi/work.accept" ? "human" : "agent",
+    inputSchema: {
+      type: "object",
+      required: ["workId", "resourceType"],
+      additionalProperties: false,
+      properties: {
+        workId: { type: "string" },
+        resourceType: { type: "string" },
+        assigneeDid: { type: "string" },
+        note: { type: "string" },
+        artifactReferences: { type: "array", items: { type: "string" } },
+        evidenceReferences: { type: "array", items: { type: "string" } }
+      }
+    },
+    execute: (inputs, ctx) => ({
+      workId: requiredString(inputs.workId, "workId"),
+      resourceType: requiredString(inputs.resourceType, "resourceType"),
+      phase,
+      assigneeDid: String(inputs.assigneeDid || ""),
+      note: String(inputs.note || ""),
+      artifactReferences: requiredArray(inputs.artifactReferences || [], "artifactReferences"),
+      evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences"),
+      actorDid: ctx.actorDid,
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  });
+}
+registerSemanticAction({
+  type: "qi/agent.invoke",
+  can: "agent/invoke",
+  kinds: ["agent_task", "question", "task"],
+  recordType: "org.ixo.topic.agent-result",
+  requiredServices: ["agents"],
+  sensitiveInputPaths: ["prompt", "toolPolicy"],
+  sensitiveOutputPaths: ["record.result"],
+  inputSchema: {
+    type: "object",
+    required: ["agentDid", "capsuleReference", "toolPolicy"],
+    additionalProperties: false,
+    properties: {
+      agentDid: { type: "string", pattern: "^did:" },
+      capsuleReference: { type: "string" },
+      toolPolicy: { type: "object" },
+      budget: { type: "object" },
+      deadline: { type: "string" },
+      executorPreference: { type: "string", enum: ["qi-flow", "qiforge", "mcp"] },
+      prompt: { type: "string" }
+    }
+  },
+  execute: async (inputs, ctx) => {
+    if (!ctx.services.agents) throw new Error("Agent runtime service is not configured");
+    const result = await ctx.services.agents.invoke({
+      agentDid: requiredString(inputs.agentDid, "agentDid"),
+      capsuleReference: requiredString(inputs.capsuleReference, "capsuleReference"),
+      toolPolicy: inputs.toolPolicy || {},
+      budget: inputs.budget,
+      deadline: inputs.deadline,
+      executorPreference: inputs.executorPreference,
+      prompt: inputs.prompt
+    });
+    return {
+      sessionId: result.sessionId,
+      result: result.result,
+      resultDigest: sha256Digest(result.result),
+      evidenceReferences: result.evidenceReferences || [],
+      evidenceDigest: sha256Digest(result.evidenceReferences || []),
+      providerReceiptReference: result.providerReceiptReference
+    };
+  }
+});
+registerSemanticAction({
+  type: "qi/agent.cancel",
+  can: "agent/cancel",
+  kinds: ["agent_task", "question", "task"],
+  recordType: "org.ixo.topic.agent-cancellation",
+  requiredServices: ["agents"],
+  inputSchema: { type: "object", required: ["sessionId"], additionalProperties: false, properties: { sessionId: { type: "string" }, reason: { type: "string" } } },
+  execute: async (inputs, ctx) => {
+    if (!ctx.services.agents) throw new Error("Agent runtime service is not configured");
+    return ctx.services.agents.cancel({ sessionId: requiredString(inputs.sessionId, "sessionId"), reason: String(inputs.reason || "") });
+  }
+});
+registerSemanticAction({
+  type: "qi/evidence.collect",
+  can: "evidence/collect",
+  kinds: ["question", "evaluation"],
+  recordType: "org.ixo.topic.evidence",
+  requiredServices: ["evidence"],
+  sensitiveOutputPaths: ["record.evidence"],
+  inputSchema: {
+    type: "object",
+    required: ["question", "sourceReferences"],
+    additionalProperties: false,
+    properties: { question: { type: "string" }, sourceReferences: { type: "array", items: { type: "string" } }, constraints: { type: "object" } }
+  },
+  execute: async (inputs, ctx) => {
+    if (!ctx.services.evidence) throw new Error("Evidence service is not configured");
+    const result = await ctx.services.evidence.collect({
+      question: requiredString(inputs.question, "question"),
+      sourceReferences: requiredArray(inputs.sourceReferences, "sourceReferences"),
+      constraints: inputs.constraints
+    });
+    return {
+      question: inputs.question,
+      evidence: result.evidence,
+      provenance: result.provenance,
+      evidenceReferences: result.evidenceReferences,
+      evidenceDigest: sha256Digest(result.evidence)
+    };
+  }
+});
+for (const accepted of [false, true]) {
+  registerSemanticAction({
+    type: accepted ? "qi/answer.accept" : "qi/answer.propose",
+    can: accepted ? "answer/accept" : "answer/propose",
+    kinds: ["question"],
+    recordType: accepted ? "org.ixo.topic.accepted-answer" : "org.ixo.topic.proposed-answer",
+    confirmation: accepted,
+    owner: accepted ? "human" : "agent",
+    inputSchema: {
+      type: "object",
+      required: accepted ? ["answer", "acceptanceAuthorityDid", "proposedAnswerRecordId"] : ["answer"],
+      additionalProperties: false,
+      properties: {
+        answer: { type: "string" },
+        proposedAnswerRecordId: { type: "string" },
+        acceptanceAuthorityDid: { type: "string", pattern: "^did:" },
+        evidenceReferences: { type: "array", items: { type: "string" } },
+        limitations: { type: "string" }
+      }
+    },
+    execute: (inputs, ctx) => ({
+      answer: requiredString(inputs.answer, "answer"),
+      status: accepted ? "accepted" : "proposed",
+      proposedAnswerRecordId: String(inputs.proposedAnswerRecordId || ""),
+      authorityDid: accepted ? requiredString(inputs.acceptanceAuthorityDid, "acceptanceAuthorityDid") : ctx.actorDid,
+      evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences"),
+      limitations: String(inputs.limitations || ""),
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  });
+}
+for (const review of [false, true]) {
+  registerSemanticAction({
+    type: review ? "qi/evaluation.review" : "qi/evaluation.run",
+    can: review ? "evaluation/review" : "evaluation/run",
+    kinds: ["evaluation", "claims"],
+    recordType: review ? "org.ixo.topic.evaluation-review" : "org.ixo.topic.evaluation-assertion",
+    requiredServices: ["evaluations"],
+    confirmation: review,
+    owner: review ? "human" : "agent",
+    inputSchema: {
+      type: "object",
+      required: review ? ["assertionReference", "methodologyRevision", "rubricRevision"] : ["subjectReference", "methodologyRevision", "rubricRevision"],
+      additionalProperties: true,
+      properties: {
+        subjectReference: { type: "string" },
+        assertionReference: { type: "string" },
+        methodologyRevision: { type: "string" },
+        rubricRevision: { type: "string" },
+        evidenceReferences: { type: "array", items: { type: "string" } }
+      }
+    },
+    execute: async (inputs, ctx) => {
+      if (!ctx.services.evaluations) throw new Error("Evaluation runtime service is not configured");
+      const result = review ? await ctx.services.evaluations.review(inputs) : await ctx.services.evaluations.run(inputs);
+      const value = "assertion" in result ? result.assertion : result.review;
+      return {
+        providerResult: value,
+        assertionId: "assertionId" in result ? result.assertionId : void 0,
+        reviewId: "reviewId" in result ? result.reviewId : void 0,
+        methodologyRevision: inputs.methodologyRevision,
+        rubricRevision: inputs.rubricRevision,
+        evaluatorDid: ctx.actorDid,
+        evidenceReferences: result.evidenceReferences,
+        signature: result.signature
+      };
+    }
+  });
+}
+registerSemanticAction({
+  type: "qi/settlement.execute",
+  can: "settlement/execute",
+  kinds: ["claims"],
+  recordType: "org.ixo.topic.settlement-record",
+  confirmation: true,
+  owner: "human",
+  riskTier: "critical",
+  requiredServices: ["settlement"],
+  inputSchema: {
+    type: "object",
+    required: ["approvedClaimReference", "amount", "asset", "recipient", "policyReference", "confirmationReference"],
+    additionalProperties: false,
+    properties: {
+      approvedClaimReference: { type: "string" },
+      amount: { type: "string" },
+      asset: { type: "string" },
+      recipient: { type: "string" },
+      policyReference: { type: "string" },
+      confirmationReference: { type: "string" }
+    }
+  },
+  execute: async (inputs, ctx) => {
+    if (!ctx.services.settlement) throw new Error("Settlement service is not configured");
+    return ctx.services.settlement.execute({
+      approvedClaimReference: requiredString(inputs.approvedClaimReference, "approvedClaimReference"),
+      amount: requiredString(inputs.amount, "amount"),
+      asset: requiredString(inputs.asset, "asset"),
+      recipient: requiredString(inputs.recipient, "recipient"),
+      policyReference: requiredString(inputs.policyReference, "policyReference"),
+      confirmationReference: requiredString(inputs.confirmationReference, "confirmationReference")
+    });
+  }
+});
+registerSemanticAction({
+  type: "qi/incident.escalate",
+  can: "incident/escalate",
+  kinds: ["incident"],
+  recordType: "org.ixo.topic.incident-escalation",
+  confirmation: true,
+  requiredServices: ["incidents"],
+  inputSchema: {
+    type: "object",
+    required: ["severity", "affectedResources", "recipients", "summary"],
+    additionalProperties: false,
+    properties: {
+      severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      affectedResources: { type: "array", items: { type: "string" } },
+      recipients: { type: "array", items: { type: "string" } },
+      evidenceReferences: { type: "array", items: { type: "string" } },
+      summary: { type: "string" }
+    }
+  },
+  execute: async (inputs, ctx) => {
+    if (!ctx.services.incidents) throw new Error("Incident service is not configured");
+    const payload = {
+      severity: requiredString(inputs.severity, "severity"),
+      affectedResources: requiredArray(inputs.affectedResources, "affectedResources"),
+      recipients: requiredArray(inputs.recipients, "recipients"),
+      evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences"),
+      summary: requiredString(inputs.summary, "summary")
+    };
+    return { ...payload, ...await ctx.services.incidents.escalate(payload) };
+  }
+});
+registerSemanticAction({
+  type: "qi/incident.mitigation.record",
+  can: "incident/mitigation.record",
+  kinds: ["incident"],
+  recordType: "org.ixo.topic.incident-mitigation",
+  inputSchema: {
+    type: "object",
+    required: ["mitigation", "affectedResources"],
+    additionalProperties: false,
+    properties: {
+      mitigation: { type: "string" },
+      affectedResources: { type: "array", items: { type: "string" } },
+      evidenceReferences: { type: "array", items: { type: "string" } },
+      occurredAt: { type: "string" }
+    }
+  },
+  execute: (inputs, ctx) => ({
+    mitigation: requiredString(inputs.mitigation, "mitigation"),
+    affectedResources: requiredArray(inputs.affectedResources, "affectedResources"),
+    evidenceReferences: requiredArray(inputs.evidenceReferences || [], "evidenceReferences"),
+    recordedBy: ctx.actorDid,
+    occurredAt: String(inputs.occurredAt || (/* @__PURE__ */ new Date()).toISOString())
+  })
+});
+
 // src/core/lib/actionRegistry/actions/calendar/eventCreate.types.ts
 var EMPTY = {
   connection: null,
@@ -11394,7 +13372,13 @@ function parseAttendeesField(raw) {
 // src/core/lib/actionRegistry/actions/calendar/eventCreate.ts
 var CALENDAR_EVENT_CREATE_SLUG = "GOOGLECALENDAR_CREATE_EVENT";
 registerAction({
-  type: "qi/calendar.event.create",
+  // Provider-explicit identity (IXO-4420 §5): this block is Google Calendar
+  // via Composio with a per-runner pinned connection — `-self` distinguishes
+  // it from the delegated `qi/googlecalendar.event.create`. The retired
+  // `qi/calendar.event.create` name resolves here via ACTION_TYPE_ALIASES.
+  // The `can` deliberately keeps its historical value so existing UCAN grants
+  // keep matching; `qi/ixo.calendar.event.*` (M4) gets its own can namespace.
+  type: "qi/googlecalendar.event.create-self",
   can: "calendar.event/create",
   sideEffect: true,
   proof: { fields: ["eventId"] },
@@ -11503,7 +13487,9 @@ registerAction({
 var CALENDAR_EVENT_UPDATE_SLUG = "GOOGLECALENDAR_UPDATE_EVENT";
 var CALENDAR_EVENT_GET_SLUG = "GOOGLECALENDAR_EVENTS_GET";
 registerAction({
-  type: "qi/calendar.event.update",
+  // Provider-explicit identity (IXO-4420 §5); `qi/calendar.event.update` is
+  // a permanent alias. `can` keeps its historical value — see eventCreate.ts.
+  type: "qi/googlecalendar.event.update-self",
   can: "calendar.event/update",
   sideEffect: true,
   proof: { fields: ["eventId"] },
@@ -11614,7 +13600,9 @@ registerAction({
 // src/core/lib/actionRegistry/actions/calendar/eventList.ts
 var CALENDAR_EVENT_LIST_SLUG = "GOOGLECALENDAR_EVENTS_LIST";
 registerAction({
-  type: "qi/calendar.event.list",
+  // Provider-explicit identity (IXO-4420 §5); `qi/calendar.event.list` is
+  // a permanent alias. `can` keeps its historical value — see eventCreate.ts.
+  type: "qi/googlecalendar.event.list-self",
   can: "calendar.event/list",
   sideEffect: false,
   proof: "none",
@@ -12424,7 +14412,7 @@ registerDiffResolver("evaluateClaim", {
 });
 
 // src/core/lib/actionRegistry/actions/calendar/eventCreate.diff.ts
-registerDiffResolver("qi/calendar.event.create", {
+registerDiffResolver("qi/googlecalendar.event.create-self", {
   resolver: async (inputs, _ctx) => {
     const attendees = parseAttendeesField(String(inputs.attendees || ""));
     const calendarId = String(inputs.calendar_id || "").trim() || "primary";
@@ -12505,7 +14493,7 @@ registerDiffResolver("qi/calendar.event.create", {
 });
 
 // src/core/lib/actionRegistry/actions/calendar/eventUpdate.diff.ts
-registerDiffResolver("qi/calendar.event.update", {
+registerDiffResolver("qi/googlecalendar.event.update-self", {
   resolver: async (inputs, ctx) => {
     const connection = inputs.connection || {};
     const connectedAccountId = connection.connectedAccountId;
@@ -12761,14 +14749,79 @@ registerDiffResolver("qi/xero.payment.create", {
   }
 });
 
+// src/core/utils/tokenAmount.ts
+var DECIMAL_RE = /^-?\d*(\.\d*)?$/;
+function toBaseUnits(displayAmount, exponent) {
+  const raw = String(displayAmount ?? "").trim();
+  if (!raw) return { ok: false, error: "Enter an amount" };
+  if (!DECIMAL_RE.test(raw)) return { ok: false, error: `\u201C${raw}\u201D is not a valid amount` };
+  if (raw.startsWith("-")) return { ok: false, error: "Amount must be greater than 0" };
+  if (!Number.isInteger(exponent) || exponent < 0) return { ok: false, error: `Unknown decimals for this token` };
+  const [whole = "", fraction = ""] = raw.split(".");
+  if (fraction.length > exponent) {
+    return {
+      ok: false,
+      error: exponent === 0 ? "This token has no decimal places \u2014 enter a whole number" : `This token has at most ${exponent} decimal places`
+    };
+  }
+  const shifted = `${whole}${fraction.padEnd(exponent, "0")}`.replace(/^0+(?=\d)/, "");
+  const value = shifted === "" ? "0" : shifted;
+  if (value === "0") return { ok: false, error: "Amount must be greater than 0" };
+  return { ok: true, value };
+}
+function toDisplayUnits(baseAmount, exponent) {
+  const raw = String(baseAmount ?? "").trim();
+  if (!raw || !DECIMAL_RE.test(raw)) return "0";
+  if (!Number.isInteger(exponent) || exponent <= 0) return raw.replace(/\..*$/, "");
+  const negative = raw.startsWith("-");
+  const digits = (negative ? raw.slice(1) : raw).replace(/\..*$/, "").padStart(exponent + 1, "0");
+  const whole = digits.slice(0, digits.length - exponent).replace(/^0+(?=\d)/, "");
+  const fraction = digits.slice(digits.length - exponent).replace(/0+$/, "");
+  return `${negative ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
+}
+function formatTokenAmount(baseAmount, denom, exponent, symbol) {
+  if (exponent === void 0 || exponent === null) return `${baseAmount} ${denom}`;
+  return `${toDisplayUnits(baseAmount, exponent)} ${symbol || denom}`;
+}
+
 // src/core/lib/actionRegistry/actions/walletFund.diff.ts
+var FALLBACK_DENOM = "uixo";
+async function describeToken(ctx, walletAddress, denom) {
+  if (!walletAddress || !ctx.handlers?.getBalances) return {};
+  try {
+    const res = await ctx.handlers.getBalances(walletAddress);
+    const match = (res?.data || []).find((b) => b.denom === denom);
+    return { symbol: match?.tokenName, exponent: match?.exponent };
+  } catch {
+    return {};
+  }
+}
 registerDiffResolver("qi/wallet.fund", {
-  resolver: async (inputs, _ctx) => {
+  resolver: async (inputs, ctx) => {
     const address = String(inputs.address || "").trim();
     const amount = String(inputs.amount || "250000").trim();
-    const network = String(inputs.network || "devnet").trim();
-    const ixoAmount = (Number(amount) / 1e6).toFixed(6);
+    const denom = String(inputs.denom || "").trim() || FALLBACK_DENOM;
+    const fromAddress = String(inputs.fromAddress || "").trim();
+    const signerAddress = (() => {
+      try {
+        return ctx.handlers?.getCurrentUser?.()?.address || "";
+      } catch {
+        return "";
+      }
+    })();
+    const source = fromAddress || signerAddress;
+    const { symbol, exponent } = await describeToken(ctx, source, denom);
     return [
+      {
+        key: "from",
+        label: "From",
+        before: "N/A",
+        // Naming the mechanism matters: spending another wallet's tokens is an
+        // authz exec, and the signer should see that before they slide.
+        after: fromAddress ? `${fromAddress} (authorized send)` : source ? `${source} (your wallet)` : "Your wallet",
+        changeType: "replace",
+        severity: fromAddress ? "warning" : "info"
+      },
       {
         key: "recipient",
         label: "Recipient",
@@ -12779,17 +14832,10 @@ registerDiffResolver("qi/wallet.fund", {
       {
         key: "amount",
         label: "Amount",
-        before: "0 IXO",
-        after: `${ixoAmount} IXO (${amount} uixo)`,
+        before: "0",
+        after: exponent === void 0 ? `${amount} ${denom}` : `${formatTokenAmount(amount, denom, exponent, symbol)} (${amount} ${denom})`,
         changeType: "replace",
         severity: "info"
-      },
-      {
-        key: "network",
-        label: "Network",
-        before: network,
-        after: network,
-        changeType: "unchanged"
       }
     ];
   }
@@ -13302,7 +15348,7 @@ registerDiffResolver(EVAL_ENGINE_ACTION_TYPE, {
         key: "decisions",
         label: "Decisions",
         before: null,
-        after: inputs?.allowChainEvaluation !== false ? "Submitted on chain, which releases payment \u2014 you grant the engine evaluator rights" : "Recorded only \u2014 nothing is submitted on chain",
+        after: inputs?.allowChainEvaluation === false ? "Recorded only \u2014 nothing is submitted on chain" : inputs?.allowZeroPayoutApprovals === true ? "Submitted on chain, including approvals that pay nothing \u2014 you grant the engine evaluator rights" : "Submitted on chain, which releases payment \u2014 you grant the engine evaluator rights",
         changeType: "add"
       }
     ];
@@ -14012,7 +16058,10 @@ function resolveReferencesDetailed(input, editorDocument, options = {}) {
   }
   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}'`);
+      warnOnce(
+        `ref-unresolved:${warnContext}:${entry.ref}`,
+        `[flow-config] ${warnContext}: reference ${entry.ref} did not resolve (${entry.reason}); using fallback '${fallback}'`
+      );
     }
   }
   return { value: result, unresolved };
@@ -14850,8 +16899,8 @@ function fnv1a322(input, seed) {
 }
 function createRunEventIdempotencyKey(kind, ...identity) {
   const canonical = JSON.stringify([kind, ...identity]);
-  const digest = `${fnv1a322(canonical, 2166136261)}${fnv1a322(canonical, 2654435761)}`;
-  return `v1:${kind.replace(/\./g, "_")}:${digest}`;
+  const digest2 = `${fnv1a322(canonical, 2166136261)}${fnv1a322(canonical, 2654435761)}`;
+  return `v1:${kind.replace(/\./g, "_")}:${digest2}`;
 }
 function boundRunActionOutput(value) {
   const byteLength = jsonByteLength(value);
@@ -17146,10 +19195,35 @@ async function executeActionBlock(params) {
   let requestedAwaitingReadBack = false;
   let proofFailureReason = null;
   let proofFailureOutput;
+  let topicRecords = [];
   const startedAt = now();
   const previousState = runtime.get(blockId);
   const attempt = (previousState.attempt || 0) + 1;
   const executionId = makeExecutionId2(now);
+  const recordTopicPhase = async (status, options = {}) => {
+    if (!params.topic || !params.topicBridge) return void 0;
+    try {
+      return await params.topicBridge.recordFlowPhase({
+        topic: params.topic,
+        actionType,
+        actorDid: params.actorDid,
+        executorDid: params.executorDid || params.actorDid,
+        executionId,
+        status,
+        input: inputBuild.inputs,
+        output: options.output,
+        semanticRecords: topicRecords,
+        flowUri,
+        sessionRunId,
+        nodeId: blockId,
+        invocationReference: options.invocationReference,
+        traceReference: sessionRunId ? `${flowUri}/session/${sessionRunId}/execution/${executionId}` : `${flowUri}/execution/${executionId}`,
+        error: options.error
+      });
+    } catch (error) {
+      return { state: "queued", error: error instanceof Error ? error.message : "Topic receipt bridge failed" };
+    }
+  };
   const timelineRequired = !!yDoc && !usesLegacyRuntimeCompatibility(yDoc);
   if (sessionRunId && (eventLog || timelineRequired)) {
     const startedLogged = await appendRunTimelineEvent({
@@ -17198,6 +19272,18 @@ async function executeActionBlock(params) {
     executionId,
     executionStartedAt: startedAt
   });
+  const runningWriteBack = await recordTopicPhase("running");
+  if (runningWriteBack?.state === "rejected") {
+    const message = runningWriteBack.error || "Topic Action execution was rejected by the receipt bridge.";
+    updateRuntimeFailure(runtime, blockId, message, now);
+    return {
+      ...buildFailureResult({ blockId, actionType, stage: "authorization", error: message, pendingInvocation: inputBuild.pendingInvocation }),
+      executionId,
+      runId: executionId,
+      topicWriteBack: runningWriteBack
+    };
+  }
+  const actionServices = action.type.startsWith("qi/topic.") ? params.services || {} : { ...params.services || {}, topic: void 0 };
   const outcome = await executeNode({
     node: flowNode,
     actorDid: params.actorDid,
@@ -17223,13 +19309,16 @@ async function executeActionBlock(params) {
         nodeId: blockId,
         flowNode,
         runtime,
-        services: params.services || {},
+        services: actionServices,
         handlers: params.handlers,
         editor,
         yDoc,
-        pendingInvocation: inputBuild.pendingInvocation
+        pendingInvocation: inputBuild.pendingInvocation,
+        topic: params.topic,
+        flowRevision: params.flowRevision
       });
       if (result.events?.length) events.push(...result.events);
+      if (result.topicRecords?.length) topicRecords = result.topicRecords;
       if (result.completion?.state === "awaiting_readback") {
         requestedAwaitingReadBack = true;
         rawReadBack = result.completion.readBack;
@@ -17292,7 +19381,12 @@ async function executeActionBlock(params) {
         invocationCid: outcome.invocationCid,
         capabilityId: outcome.capabilityId,
         executionId,
-        runId: executionId
+        runId: executionId,
+        topicWriteBack: await recordTopicPhase(proofFailureState === "needs_verification" ? "needs_verification" : "failed", {
+          output: proofFailureOutput,
+          error: { code: PROOF_MISSING_CODE, message },
+          invocationReference: outcome.invocationCid || outcome.capabilityId
+        })
       };
     }
     updateRuntimeFailure(runtime, blockId, message, now);
@@ -17317,6 +19411,10 @@ async function executeActionBlock(params) {
         now
       });
     }
+    const topicWriteBack2 = await recordTopicPhase(outcome.stage === "authorization" ? "rejected" : "failed", {
+      error: { message },
+      invocationReference: outcome.invocationCid || outcome.capabilityId
+    });
     return {
       ...buildFailureResult({
         blockId,
@@ -17328,7 +19426,8 @@ async function executeActionBlock(params) {
       invocationCid: outcome.invocationCid,
       capabilityId: outcome.capabilityId,
       executionId,
-      runId: executionId
+      runId: executionId,
+      topicWriteBack: topicWriteBack2
     };
   }
   const output = outcome.result?.payload || {};
@@ -17441,6 +19540,11 @@ async function executeActionBlock(params) {
     });
   }
   const pendingInvocationRemoved = completionState === "completed" ? cleanupCompletedPendingInvocation(yDoc, blockId, inputBuild.pendingInvocation, sessionRunId) : false;
+  const topicWriteBack = await recordTopicPhase(completionState === "completed" ? "succeeded" : completionState === "needs_verification" ? "needs_verification" : "failed", {
+    output,
+    ...boundedOutput.exceeded ? { error: { code: "RUN_OUTPUT_TOO_LARGE", message: `Action output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.` } } : {},
+    invocationReference: outcome.invocationCid || outcome.capabilityId
+  });
   return {
     success: !boundedOutput.exceeded,
     stage: outcome.stage,
@@ -17458,7 +19562,8 @@ async function executeActionBlock(params) {
     executionId,
     pendingInvocationRemoved,
     completionState,
-    pendingInvocation: inputBuild.pendingInvocation
+    pendingInvocation: inputBuild.pendingInvocation,
+    topicWriteBack
   };
 }
 
@@ -18160,6 +20265,17 @@ function compileBlockProps(cap, registryType) {
 var COMPILED_BLOCK_TYPE = "action";
 
 // src/core/lib/flowCompiler/compiler.ts
+function stripActiveScheduleBindings(plan) {
+  let changed = false;
+  const capabilities = plan.capabilities.map((cap) => {
+    if (cap.trigger?.type !== "schedule") return cap;
+    if (cap.trigger.scheduleRef === void 0 && cap.trigger.scheduleRevision === void 0) return cap;
+    changed = true;
+    const { scheduleRef: _ref, scheduleRevision: _rev, ...inactive } = cap.trigger;
+    return { ...cap, trigger: inactive };
+  });
+  return changed ? { ...plan, capabilities } : plan;
+}
 function compileBaseUcanFlow(plan, registry) {
   if (!Array.isArray(plan.capabilities)) {
     throw new Error("BaseUcanFlow.capabilities must be an array");
@@ -18257,6 +20373,21 @@ function compileBaseUcanFlow(plan, registry) {
         });
       }
     }
+    if (trigger.type === "schedule") {
+      if (action.eligibleForTimeTrigger !== true) {
+        throw new Error(
+          `Block "${nodeId}" is configured with a schedule trigger, but its action type "${action.type}" is not marked eligibleForTimeTrigger. Set eligibleForTimeTrigger: true on the action definition or change the trigger.`
+        );
+      }
+      if (trigger.sourceBlockId || trigger.sources || trigger.eventName) {
+        throw new Error(
+          `Block "${nodeId}" has a schedule trigger carrying event-trigger fields (sourceBlockId/eventName/sources). A schedule trigger holds only scheduleRef and scheduleRevision \u2014 timing lives in the referenced ScheduleSpec, never in the block.`
+        );
+      }
+      if (trigger.scheduleRevision !== void 0 && (!Number.isInteger(trigger.scheduleRevision) || trigger.scheduleRevision < 1)) {
+        throw new Error(`Block "${nodeId}" has a schedule trigger with an invalid scheduleRevision (must be an integer >= 1).`);
+      }
+    }
     if (trigger.type === "block.event" || trigger.type === "block.event.all") {
       const refs = collectOutputRefs(cap.nb || {});
       for (const ref of refs) {
@@ -18974,7 +21105,8 @@ function readFlow() {
 }
 async function setupFlowFromBaseUcan(options) {
   const { plan: rawPlan, roomId, matrixClient, creatorDid, docId, templateId, strategy = "full" } = options;
-  const plan = rawPlan.flowId ? rawPlan : { ...rawPlan, flowId: docId || roomId };
+  const identified = rawPlan.flowId ? rawPlan : { ...rawPlan, flowId: docId || roomId };
+  const plan = templateId ? stripActiveScheduleBindings(identified) : identified;
   const incomingCompiled = compileBaseUcanFlow(plan, { getActionByCan });
   const { yDoc, provider } = await connectToRoom(roomId, matrixClient, { adoptRuns: true });
   let finalCompiled;
@@ -20290,10 +22422,17 @@ export {
   matrixUserIdToDid,
   findOrCreateDMRoom,
   sendDirectMessage,
+  canonicalActionJson,
+  sha256Digest,
+  MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT,
+  MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES,
+  validateTopicSemanticRecord,
+  validateTopicSemanticRecordBatch,
   canToType,
   typeToCan,
   getAllCanMappings,
   warnOnce,
+  getActionPresentation,
   STEP_COMPLETED_EVENT_NAME,
   STEP_COMPLETED_EVENT,
   doneWhenCompleted,
@@ -20312,7 +22451,10 @@ export {
   getActionByCan,
   getEventsForBlock,
   getOutputSchemaForBlock,
+  ACTION_MANIFEST_VERSION,
+  ACTION_REGISTRY_VERSION,
   generateActionManifest,
+  actionManifestIssues,
   isBlankInputValue,
   getMissingActionInputs,
   SERVICE_VERBS,
@@ -20361,6 +22503,7 @@ export {
   DIFFERENT_WHEN_OTHER_MAX,
   normalizeDifferentWhen,
   normalizeRepeatSubmissions,
+  FORM_SEGMENT,
   extractRubricFieldCatalog,
   buildRubricEnvelope,
   parsePublishedRubric,
@@ -20400,6 +22543,8 @@ export {
   renderNumber,
   formatCoin2 as formatCoin,
   formatCoinAmount,
+  toBaseUnits,
+  formatTokenAmount,
   DM_NOTIFICATIONS_MAP_KEY,
   getDMNotificationState,
   setDMNotificationRecord,
@@ -20602,4 +22747,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-ZXNBOVAA.js.map
+//# sourceMappingURL=chunk-TBCPHCFA.js.map