xytara 2.0.0 → 2.2.0

package/examples/quickstart.js

@@ -0,0 +1,3255 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+const {
+  createClient,
+  exportIntegrationSubmissionBundleSet
+} = require("../index.js");
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const client = createClient({
+      baseUrl,
+      apiKey: "demo-api-key",
+      walletId: "demo-wallet",
+      walletSecret: "demo-wallet-secret",
+      accountId: "acct_demo"
+    });
+
+    const health = await client.getHealth();
+    assert.strictEqual(health.status, "ok", "health missing");
+    const healthSummary = await client.getHealthSummary();
+    assert.strictEqual(healthSummary.status, "ok", "health summary missing");
+    const ready = await client.waitForHealth({
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(ready.readiness, "ready", "health readiness missing");
+    const readySummary = await client.waitForHealthSummary({
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(readySummary.readiness, "ready", "health summary missing");
+
+    const summary = await client.fetchCatalogSummary(true);
+    assert.strictEqual(typeof summary.task_count, "number", "catalog summary missing");
+    assert.strictEqual(Array.isArray(summary.task_refs), true, "catalog summary task refs missing");
+    assert.strictEqual(Array.isArray(summary.workflow_refs), true, "catalog summary workflow refs missing");
+    assert.strictEqual(summary.task_count >= 20, true, "catalog summary breadth missing");
+    assert.strictEqual(summary.workflow_count >= 5, true, "workflow summary breadth missing");
+    assert.strictEqual(summary.task_refs.includes("a2a.negotiate"), true, "a2a task carry missing");
+    assert.strictEqual(summary.task_refs.includes("a2c.session.open"), true, "a2c task carry missing");
+    assert.strictEqual(summary.task_refs.includes("identity.attest.preview"), true, "identity task carry missing");
+    assert.strictEqual(summary.workflow_refs.includes("a2a.settlement.flow"), true, "a2a workflow carry missing");
+    assert.strictEqual(summary.workflow_refs.includes("identity.anchor.flow"), true, "identity workflow carry missing");
+    const defaultTransactionCenter = await client.getDefaultTransactionCenter(true);
+    assert.strictEqual(defaultTransactionCenter.default_protocol.protocol, "mcp", "default transaction center protocol missing");
+    assert.strictEqual(defaultTransactionCenter.default_payment.protocol, "x402", "default transaction center payment missing");
+    assert.strictEqual(defaultTransactionCenter.default_settlement.settlement_mode, "bsv_teranode", "default transaction center settlement missing");
+    const defaultTransactionCenterSummary = await client.getDefaultTransactionCenterSummary(true);
+    assert.strictEqual(defaultTransactionCenterSummary.default_protocol, "mcp", "default transaction center summary protocol missing");
+    assert.strictEqual(defaultTransactionCenterSummary.default_payment_protocol, "x402", "default transaction center summary payment missing");
+    assert.strictEqual(defaultTransactionCenterSummary.default_settlement_mode, "bsv_teranode", "default transaction center summary settlement missing");
+    assert.strictEqual(defaultTransactionCenterSummary.suggested_path_count >= 2, true, "default transaction center paths missing");
+    const defaultTransactionEconomics = await client.getDefaultTransactionEconomics(true);
+    assert.strictEqual(defaultTransactionEconomics.payment_protocol, "x402", "default transaction economics payment missing");
+    assert.strictEqual(defaultTransactionEconomics.default_settlement_mode, "bsv_teranode", "default transaction economics settlement missing");
+    assert.strictEqual(Array.isArray(defaultTransactionEconomics.supported_settlement_modes), true, "default transaction economics modes missing");
+    const defaultTransactionEconomicsSummary = await client.getDefaultTransactionEconomicsSummary(true);
+    assert.strictEqual(defaultTransactionEconomicsSummary.treasury_destination_kind, "account_treasury", "default transaction economics summary treasury missing");
+    const defaultTaskPacks = await client.getDefaultTaskPacks(true);
+    assert.strictEqual(defaultTaskPacks.pack_count >= 3, true, "default task packs missing");
+    assert.strictEqual(defaultTaskPacks.packs.some((entry) => entry.pack_ref === "default.mcp.tool.invoke"), true, "default mcp task pack missing");
+    const defaultTaskPacksSummary = await client.getDefaultTaskPacksSummary(true);
+    assert.strictEqual(defaultTaskPacksSummary.workflow_pack_count >= 2, true, "default workflow task packs missing");
+    const defaultTaskPack = await client.getDefaultTaskPack("default.a2c.tooling.run", true);
+    assert.strictEqual(defaultTaskPack.workflow_ref, "a2c.tooling.flow", "default task pack workflow missing");
+    const defaultGuidedLoops = await client.getDefaultGuidedLoops(true);
+    assert.strictEqual(Array.isArray(defaultGuidedLoops.loops), true, "default guided loops missing");
+    assert.strictEqual(defaultGuidedLoops.loop_count >= 3, true, "default guided loop count missing");
+    const defaultGuidedLoopsSummary = await client.getDefaultGuidedLoopsSummary(true);
+    assert.strictEqual(defaultGuidedLoopsSummary.loop_refs.includes("default.mcp.loop"), true, "default guided loop summary missing");
+    const defaultGuidedLoop = await client.getDefaultGuidedLoop("default.a2c.tooling.loop", true);
+    assert.strictEqual(defaultGuidedLoop.pack_ref, "default.a2c.tooling.run", "default guided loop pack ref missing");
+    const transactionClassPacks = await client.getTransactionClassPacks(true);
+    assert.strictEqual(transactionClassPacks.class_pack_count >= 5, true, "transaction class pack catalog missing");
+    const transactionClassPackSummary = await client.getTransactionClassPacksSummary(true);
+    assert.strictEqual(transactionClassPackSummary.class_pack_refs.includes("transaction.registry.anchor"), true, "transaction class pack summary missing");
+    const transactionClassPack = await client.getTransactionClassPack("transaction.registry.anchor", true);
+    assert.strictEqual(transactionClassPack.workflow_ref, "registry.anchor.flow", "transaction class pack workflow missing");
+    const precommitPacks = await client.getPrecommitInteractionPacks(true);
+    assert.strictEqual(precommitPacks.precommit_pack_count >= 3, true, "precommit pack catalog missing");
+    const precommitPackSummary = await client.getPrecommitInteractionPacksSummary(true);
+    assert.strictEqual(precommitPackSummary.precommit_pack_refs.includes("precommit.a2a.settlement.readiness"), true, "precommit pack summary missing");
+    const precommitPack = await client.getPrecommitInteractionPack("precommit.job.commitment.readiness", true);
+    assert.strictEqual(precommitPack.recommended_next_ref, "transaction.job.commitment", "precommit pack detail missing");
+    const spinePaths = await client.getInteractionSpinePaths(true);
+    assert.strictEqual(spinePaths.spine_path_count >= 3, true, "spine path catalog missing");
+    const spinePathSummary = await client.getInteractionSpinePathsSummary(true);
+    assert.strictEqual(spinePathSummary.spine_path_refs.includes("spine.job.commitment"), true, "spine path summary missing");
+    const spinePath = await client.getInteractionSpinePath("spine.job.commitment", true);
+    assert.strictEqual(spinePath.committed_ref, "transaction.job.commitment", "spine path detail missing");
+    const resultPackages = await client.getInteractionResultPackages(true);
+    assert.strictEqual(resultPackages.result_package_count >= 3, true, "interaction result package catalog missing");
+    const resultPackageSummary = await client.getInteractionResultPackagesSummary(true);
+    assert.strictEqual(resultPackageSummary.result_package_refs.includes("result.spine.job.commitment"), true, "interaction result package summary missing");
+    const resultPackage = await client.getInteractionResultPackage("result.spine.job.commitment", true);
+    assert.strictEqual(resultPackage.source_ref, "spine.job.commitment", "interaction result package detail missing");
+    const resultPackageExportTemplate = await client.getInteractionResultPackageExportTemplate("result.spine.job.commitment");
+    assert.strictEqual(resultPackageExportTemplate.export_template.recommended_proof_surface, "/v1/proof-center/result-package-handoff/run", "interaction result package export template missing");
+    const resultPackageContinuations = await client.getInteractionResultPackageContinuations(true);
+    assert.strictEqual(resultPackageContinuations.continuation_count >= 3, true, "interaction result package continuation catalog missing");
+    const resultPackageContinuationSummary = await client.getInteractionResultPackageContinuationsSummary(true);
+    assert.strictEqual(resultPackageContinuationSummary.continuation_refs.includes("continue.result.spine.job.commitment"), true, "interaction result package continuation summary missing");
+    const resultPackageContinuation = await client.getInteractionResultPackageContinuation("continue.result.spine.job.commitment", true);
+    assert.strictEqual(resultPackageContinuation.result_package_ref, "result.spine.job.commitment", "interaction result package continuation detail missing");
+    const integrationSummary = await client.getIntegrationSummaries({
+      source: "builtin",
+      certification_state: "certified",
+      integration_maturity: "production_default",
+      bundled: "true"
+    });
+    assert.strictEqual(typeof integrationSummary.integration_count, "number", "integration summary missing");
+    assert.strictEqual(integrationSummary.certified_integration_count >= 5, true, "integration certification breadth missing");
+    assert.strictEqual(integrationSummary.production_default_count >= 5, true, "integration maturity breadth missing");
+    const integrationClasses = await client.listIntegrationClasses();
+    assert.strictEqual(integrationClasses.some((entry) => entry.adapter_class === "execution_adapter"), true, "integration execution class missing");
+    assert.strictEqual(integrationClasses.some((entry) => entry.adapter_class === "settlement_adapter"), true, "integration settlement class missing");
+    const integrationProtocols = await client.listIntegrationProtocols();
+    assert.strictEqual(integrationProtocols.some((entry) => entry.protocol === "mcp"), true, "integration protocol mcp missing");
+    assert.strictEqual(integrationProtocols.some((entry) => entry.protocol === "x402"), true, "integration protocol x402 missing");
+    const integrationSettlementModes = await client.listIntegrationSettlementModes();
+    assert.strictEqual(integrationSettlementModes.some((entry) => entry.settlement_mode === "evm_payment"), true, "integration settlement mode missing");
+    const certifiedBuiltinIntegrations = await client.listIntegrations({
+      source: "builtin",
+      certification_state: "certified",
+      integration_maturity: "production_default"
+    });
+    assert.strictEqual(certifiedBuiltinIntegrations.length >= 5, true, "certified integration discovery missing");
+    assert.strictEqual(
+      certifiedBuiltinIntegrations.some((entry) => entry.integration_id === "partner.protocol.acme_mcp"),
+      false,
+      "staged partner integration should not appear in builtin-certified defaults"
+    );
+    const mcpIntegration = await client.getIntegration("builtin.protocol.mcp");
+    assert.strictEqual(mcpIntegration.certification_state, "certified", "mcp integration certification state mismatch");
+    assert.strictEqual(mcpIntegration.integration_maturity, "production_default", "mcp integration maturity mismatch");
+    assert.strictEqual(mcpIntegration.operational_readiness.supports_default_selection, true, "mcp integration selection posture mismatch");
+    const stagedPartnerIntegrations = await client.listIntegrations({
+      source: "third_party_example",
+      bundled: "false"
+    });
+    assert.strictEqual(stagedPartnerIntegrations.length >= 2, true, "staged partner integration discovery missing");
+    assert.strictEqual(
+      stagedPartnerIntegrations.every((entry) => entry.registration.requires_explicit_selection === true),
+      true,
+      "staged partner integrations should require explicit selection"
+    );
+    const submissionBundleSet = exportIntegrationSubmissionBundleSet({
+      source: "third_party_example",
+      bundled: "false"
+    }, "quickstart bundle-set review");
+    assert.strictEqual(submissionBundleSet.bundle_count >= 2, true, "submission bundle-set export missing");
+    assert.strictEqual(submissionBundleSet.notes, "quickstart bundle-set review", "submission bundle-set notes mismatch");
+    const builtinPromotionActionSet = await client.getIntegrationPromotionActionSet("builtin.protocol.mcp");
+    assert.strictEqual(builtinPromotionActionSet.ok, true, "builtin promotion action-set missing");
+    assert.strictEqual(
+      builtinPromotionActionSet.actions.some((entry) => entry.request.action === "maintain_production_default" && entry.valid_now === true),
+      true,
+      "builtin promotion action-set steady-state preview missing"
+    );
+    const stagedPromotionActionSet = await client.getIntegrationPromotionActionSet("partner.protocol.acme_mcp");
+    assert.strictEqual(stagedPromotionActionSet.ok, true, "staged promotion action-set missing");
+    assert.strictEqual(
+      stagedPromotionActionSet.actions.some((entry) => entry.request.action === "complete_certification" && entry.valid_now === true),
+      true,
+      "staged promotion action-set certification preview missing"
+    );
+    const stagedPromotionActionPreview = await client.previewIntegrationPromotionAction({
+      integration_id: "partner.protocol.acme_mcp",
+      action: "complete_certification"
+    });
+    assert.strictEqual(stagedPromotionActionPreview.ok, true, "staged promotion action preview missing");
+    assert.strictEqual(stagedPromotionActionPreview.valid_now, true, "staged promotion action preview validity mismatch");
+    assert.strictEqual(
+      stagedPromotionActionPreview.resulting_posture.promotion_readiness.blockers.includes("not_marked_production_default"),
+      true,
+      "staged promotion action resulting posture missing maturity blocker"
+    );
+    const promotionActionList = await client.listIntegrationPromotionActionSets({
+      source: "third_party_example",
+      bundled: "false"
+    });
+    assert.strictEqual(promotionActionList.integration_count >= 3, true, "promotion action list breadth missing");
+    assert.strictEqual(
+      promotionActionList.valid_actions.some((entry) => entry.action === "complete_certification"),
+      true,
+      "promotion action list valid-action summary missing"
+    );
+    const integrationSelectedQuote = await client.createTaskSetQuote([
+      {
+        task_ref: "adapter.mcp.invoke",
+        body: {
+          tool_name: "summarize",
+          arguments: { text: "integration-selection-quickstart" }
+        }
+      }
+    ], {
+      command: "quickstart-integration-selected-quote",
+      protocol: "mcp",
+      paymentProtocol: "x402",
+      integrationId: "builtin.protocol.mcp",
+      integrationIds: ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"],
+      settlementMode: "evm_payment"
+    });
+    assert.strictEqual(integrationSelectedQuote.ok, true, "integration-selected quote response missing");
+    assert.strictEqual(Array.isArray(integrationSelectedQuote.quote.integration_ids), true, "integration-selected quote missing integration ids");
+    assert.strictEqual(integrationSelectedQuote.quote.integration_ids.includes("builtin.protocol.mcp"), true, "integration-selected quote missing mcp integration");
+    assert.strictEqual(integrationSelectedQuote.quote.integration_ids.includes("builtin.payment.x402"), true, "integration-selected quote missing x402 integration");
+    assert.strictEqual(integrationSelectedQuote.quote.settlement_integration_id, "builtin.settlement.chain", "integration-selected quote settlement integration mismatch");
+    assert.strictEqual(integrationSelectedQuote.quote.integration_preference.primary_id, "builtin.protocol.mcp", "integration-selected quote preference mismatch");
+    assert.strictEqual(integrationSelectedQuote.quote.payment.protocol, "x402", "integration-selected quote payment protocol missing");
+    assert.strictEqual(integrationSelectedQuote.quote.settlement.integration_id, "builtin.settlement.chain", "integration-selected quote settlement object mismatch");
+    assert.strictEqual(typeof integrationSelectedQuote.quote.treasury.destination_id, "string", "integration-selected quote treasury destination missing");
+    assert.strictEqual(integrationSelectedQuote.quote.default_path.path_kind, "first_party_default", "integration-selected quote default path kind missing");
+    assert.strictEqual(integrationSelectedQuote.quote.default_path.selection_origin, "explicit_or_constrained", "integration-selected quote path origin missing");
+    const defaultMcpPreview = await client.previewDefaultMcpToolQuote("summarize", {
+      text: "default-mcp-preview"
+    }, {
+      command: "quickstart-default-mcp-preview"
+    });
+    const defaultMcpPreviewSummary = client.summarizeQuotePreview(defaultMcpPreview);
+    assert.strictEqual(defaultMcpPreviewSummary.payment_required, true, "default mcp preview should require payment");
+    assert.strictEqual(defaultMcpPreview.quote.payment.protocol, "x402", "default mcp preview payment protocol missing");
+    assert.strictEqual(defaultMcpPreview.quote.settlement.mode, "bsv_teranode", "default mcp preview settlement missing");
+    assert.strictEqual(defaultMcpPreview.quote.default_path.path_kind, "first_party_default", "default mcp preview path kind missing");
+    const defaultMcpQuote = await client.createDefaultMcpToolQuote("summarize", {
+      text: "default-mcp-quote-summary"
+    }, {
+      command: "quickstart-default-mcp-quote-summary"
+    });
+    assert.strictEqual(defaultMcpQuote.quote.payment.protocol, "x402", "default mcp quote payment protocol missing");
+    assert.strictEqual(defaultMcpQuote.quote.settlement.mode, "bsv_teranode", "default mcp quote settlement missing");
+    const defaultTaskPackPreview = await client.previewDefaultTaskPackQuote("default.a2c.tooling.run", {
+      agent_id: "agent-demo",
+      channel_ref: "channel-default",
+      pack_ref: "pack.tools.research",
+      tool_name: "summarize",
+      arguments: { text: "default-task-pack-preview" }
+    }, {
+      command: "quickstart-default-task-pack-preview"
+    });
+    assert.strictEqual(defaultTaskPackPreview.quote.payment.protocol, "x402", "default task pack preview payment protocol missing");
+    assert.strictEqual(defaultTaskPackPreview.quote.settlement.mode, "bsv_teranode", "default task pack preview settlement missing");
+    assert.strictEqual(defaultTaskPackPreview.quote.task_count, 3, "default task pack preview task count missing");
+    const defaultTaskPackResult = await client.invokeDefaultTaskPack("default.mcp.tool.invoke", {
+      tool_name: "summarize",
+      arguments: { text: "default-task-pack-invoke" }
+    }, {
+      command: "quickstart-default-task-pack-invoke"
+    });
+    assert.strictEqual(defaultTaskPackResult.transaction.execution.task_count, 1, "default task pack invoke task count missing");
+    assert.strictEqual(defaultTaskPackResult.command.deliverables[0].kind, "result", "default task pack invoke deliverable missing");
+    assert.strictEqual(defaultTaskPackResult.command.deliverables[0].task_ref, "adapter.mcp.invoke", "default task pack invoke task ref missing");
+    const defaultGuidedLoopResult = await client.runDefaultGuidedLoop("default.mcp.loop", {
+      tool_name: "summarize",
+      arguments: { text: "default-guided-loop-run" }
+    }, {
+      command: "quickstart-default-guided-loop-run"
+    });
+    assert.strictEqual(defaultGuidedLoopResult.loop.loop_ref, "default.mcp.loop", "default guided loop result ref missing");
+    assert.strictEqual(defaultGuidedLoopResult.result_set_summary.transaction_status, "completed", "default guided loop transaction summary missing");
+    assert.strictEqual(defaultGuidedLoopResult.linked_record_summary.payment_ledger_count >= 1, true, "default guided loop payment ledger missing");
+    assert.strictEqual(defaultGuidedLoopResult.economics_summary.default_settlement_mode, "bsv_teranode", "default guided loop economics missing");
+    const defaultGuidedLoopSummary = await client.runDefaultGuidedLoopSummary("default.mcp.loop", {
+      tool_name: "summarize",
+      arguments: { text: "default-guided-loop-run-summary" }
+    }, {
+      command: "quickstart-default-guided-loop-run-summary"
+    });
+    assert.strictEqual(defaultGuidedLoopSummary.loop_ref, "default.mcp.loop", "default guided loop summary ref missing");
+    assert.strictEqual(defaultGuidedLoopSummary.payment_ledger_count >= 1, true, "default guided loop summary payment ledger missing");
+    const transactionClassResult = await client.runTransactionClassPack("transaction.registry.anchor", {
+      subject_id: "subject-registry-quickstart",
+      record_type: "trust",
+      commitment_hash: "commitment-registry-quickstart"
+    }, {
+      command: "quickstart-transaction-class-registry-anchor"
+    });
+    assert.strictEqual(transactionClassResult.class_pack.class_pack_ref, "transaction.registry.anchor", "transaction class pack result missing");
+    assert.strictEqual(transactionClassResult.result_set_summary.transaction_status, "completed", "transaction class result-set missing");
+    assert.strictEqual(transactionClassResult.proof_handoff_summary.proof_ready, true, "transaction class proof handoff readiness missing");
+    assert.strictEqual(transactionClassResult.proof_handoff_summary.recommended_proof_loop, "default.proof.bundle.loop", "transaction class proof handoff recommendation missing");
+    const transactionClassSummary = await client.runTransactionClassPackSummary("transaction.registry.anchor", {
+      subject_id: "subject-registry-summary",
+      record_type: "trust",
+      commitment_hash: "commitment-registry-summary"
+    }, {
+      command: "quickstart-transaction-class-registry-anchor-summary"
+    });
+    assert.strictEqual(transactionClassSummary.class_pack_ref, "transaction.registry.anchor", "transaction class summary ref missing");
+    assert.strictEqual(transactionClassSummary.proof_handoff_summary.proof_ready, true, "transaction class summary proof handoff missing");
+    const precommitResult = await client.runPrecommitInteractionPack("precommit.job.commitment.readiness", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-1",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      intent_id: "intent-quickstart-1",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-precommit-job-readiness"
+    });
+    assert.strictEqual(precommitResult.precommit_pack.precommit_pack_ref, "precommit.job.commitment.readiness", "precommit pack result missing");
+    assert.strictEqual(precommitResult.precommit_readiness_summary.readiness_posture, "ready_for_committed_run", "precommit readiness posture missing");
+    const precommitSummary = await client.runPrecommitInteractionPackSummary("precommit.job.commitment.readiness", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-2",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      intent_id: "intent-quickstart-2",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-precommit-job-readiness-summary"
+    });
+    assert.strictEqual(precommitSummary.precommit_pack_ref, "precommit.job.commitment.readiness", "precommit summary ref missing");
+    assert.strictEqual(precommitSummary.precommit_readiness_summary.recommended_next_ref, "transaction.job.commitment", "precommit summary next ref missing");
+    const spineResult = await client.runInteractionSpinePath("spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-3",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-spine-job-commitment"
+    });
+    assert.strictEqual(spineResult.spine_path.spine_path_ref, "spine.job.commitment", "spine path result missing");
+    assert.strictEqual(spineResult.spine_summary.precommit_readiness_summary.readiness_posture, "ready_for_committed_run", "spine path readiness missing");
+    assert.strictEqual(spineResult.spine_summary.proof_handoff_summary.proof_ready, true, "spine path proof handoff missing");
+    const spineSummary = await client.runInteractionSpinePathSummary("spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-4",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-spine-job-commitment-summary"
+    });
+    assert.strictEqual(spineSummary.spine_path_ref, "spine.job.commitment", "spine summary ref missing");
+    assert.strictEqual(spineSummary.spine_summary.proof_handoff_summary.proof_ready, true, "spine summary proof handoff missing");
+    const resultPackageResult = await client.runInteractionResultPackage("result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-5",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-job-commitment"
+    });
+    assert.strictEqual(resultPackageResult.result_package.result_package_ref, "result.spine.job.commitment", "result package ref missing");
+    assert.strictEqual(resultPackageResult.result_package_summary.transaction_status, "completed", "result package summary missing");
+    assert.strictEqual(resultPackageResult.seam_summary.payment_settlement_treasury_summary.payment_ledger_count >= 1, true, "result package seam payment ledger missing");
+    assert.strictEqual(resultPackageResult.seam_summary.proof_handoff_summary.proof_ready, true, "result package proof handoff missing");
+    const resultPackageSummaryRun = await client.runInteractionResultPackageSummary("result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-6",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-job-commitment-summary"
+    });
+    assert.strictEqual(resultPackageSummaryRun.result_package_ref, "result.spine.job.commitment", "result package summary ref missing");
+    assert.strictEqual(resultPackageSummaryRun.result_package_summary.transaction_status, "completed", "result package summarized transaction status missing");
+    assert.strictEqual(resultPackageSummaryRun.seam_summary.proof_handoff_summary.proof_ready, true, "result package summarized proof handoff missing");
+    const resultPackageExport = await client.exportInteractionResultPackage("result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-7",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-export"
+    });
+    assert.strictEqual(resultPackageExport.portable_handoff_bundle.result_package_ref, "result.spine.job.commitment", "result package export bundle ref missing");
+    assert.strictEqual(resultPackageExport.portable_handoff_bundle.committed_ref, "transaction.job.commitment", "result package export committed ref missing");
+    assert.strictEqual(resultPackageExport.economic_consequence_handoff_bundle, null, "direct-pay result package export should not auto-carry an economic consequence bundle");
+    const resultPackageExportSummary = await client.exportInteractionResultPackageSummary("result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-8",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-export-summary"
+    });
+    assert.strictEqual(resultPackageExportSummary.portable_handoff_summary.seam_layer_count >= 3, true, "result package export summary seam layers missing");
+    assert.strictEqual(resultPackageExportSummary.portable_handoff_summary.committed_ref, "transaction.job.commitment", "result package export summary committed ref missing");
+    const resultPackageContinuationRun = await client.runInteractionResultPackageContinuation("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-9",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation"
+    });
+    assert.strictEqual(resultPackageContinuationRun.continuation.continuation_ref, "continue.result.spine.job.commitment", "result package continuation ref missing");
+    assert.strictEqual(resultPackageContinuationRun.continuation_summary.continuation_ready, true, "result package continuation readiness missing");
+    assert.strictEqual(resultPackageContinuationRun.continuation_summary.default_proof_surface, "/v1/proof-center/result-package-handoff/run", "result package continuation default proof surface missing");
+    const resultPackageContinuationRunSummary = await client.runInteractionResultPackageContinuationSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-10",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-summary"
+    });
+    assert.strictEqual(resultPackageContinuationRunSummary.continuation_ref, "continue.result.spine.job.commitment", "result package continuation summary ref missing");
+    assert.strictEqual(resultPackageContinuationRunSummary.continuation_summary.continuation_ready, true, "result package continuation summary readiness missing");
+    const resultPackageContinuationPreparation = await client.prepareInteractionResultPackageContinuation("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-11",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-prepare"
+    });
+    assert.strictEqual(resultPackageContinuationPreparation.proof_request_template.target_surface, "/v1/proof-center/result-package-handoff/run", "result package continuation preparation target surface missing");
+    assert.strictEqual(resultPackageContinuationPreparation.proof_request_template.request_template.handoff_bundle.result_package_ref, "result.spine.job.commitment", "result package continuation preparation bundle ref missing");
+    assert.strictEqual(resultPackageContinuationPreparation.prepared_artifact_summary.prepared_artifact_ref, "prepared.continue.result.spine.job.commitment", "prepared continuation artifact ref missing");
+    assert.strictEqual(resultPackageContinuationPreparation.prepared_artifact_summary.durable_path.proof_ready, true, "prepared continuation proof readiness missing");
+    assert.strictEqual(resultPackageContinuationPreparation.extension_seam_summary.extension_seam_ref, "extension.continue.result.spine.job.commitment", "prepared continuation extension seam ref missing");
+    assert.strictEqual(resultPackageContinuationPreparation.extension_seam_summary.future_adapter_hook_count, 3, "prepared continuation extension hook count missing");
+    const resultPackageContinuationPreparationSummary = await client.prepareInteractionResultPackageContinuationSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-prepare-summary"
+    });
+    assert.strictEqual(resultPackageContinuationPreparationSummary.continuation_ready, true, "result package continuation preparation summary readiness missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.review_surface, "/v1/proof-center/result-package-handoff/review", "result package continuation preparation review surface missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.prepared_artifact_ref, "prepared.continue.result.spine.job.commitment", "result package continuation preparation summary artifact ref missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.proof_ready, true, "result package continuation preparation summary proof readiness missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.extension_seam_ref, "extension.continue.result.spine.job.commitment", "result package continuation preparation summary seam ref missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.reusable_default_ref, "default.continue.result.spine.job.commitment", "result package continuation preparation summary default ref missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.default_review_surface, "/v1/proof-center/result-package-handoff/review/default-continuation", "result package continuation preparation summary default review surface missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.reusable_by_default, true, "result package continuation preparation summary reusable-by-default missing");
+    assert.strictEqual(resultPackageContinuationPreparationSummary.future_adapter_hook_count, 3, "result package continuation preparation summary hook count missing");
+    const resultPackageContinuationArtifactSummary = await client.prepareInteractionResultPackageContinuationArtifactSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-artifact-summary"
+    });
+    assert.strictEqual(resultPackageContinuationArtifactSummary.prepared_artifact_ref, "prepared.continue.result.spine.job.commitment", "result package continuation artifact summary ref missing");
+    assert.strictEqual(resultPackageContinuationArtifactSummary.review_surface, "/v1/proof-center/result-package-handoff/review", "result package continuation artifact summary review surface missing");
+    assert.strictEqual(resultPackageContinuationArtifactSummary.proof_ready, true, "result package continuation artifact summary proof readiness missing");
+    assert.strictEqual(resultPackageContinuationArtifactSummary.extension_seam_summary.extension_seam_ref, "extension.continue.result.spine.job.commitment", "result package continuation artifact summary seam ref missing");
+    assert.strictEqual(resultPackageContinuationArtifactSummary.reusable_default_summary.reusable_default_ref, "default.continue.result.spine.job.commitment", "result package continuation artifact summary default ref missing");
+    assert.strictEqual(resultPackageContinuationArtifactSummary.extension_template.target_surface, "/v1/proof-center/result-package-handoff/review/extension-readiness", "result package continuation artifact summary extension target surface missing");
+    const resultPackageReusableDefaultSummary = await client.prepareInteractionResultPackageReusableDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-default-summary"
+    });
+    assert.strictEqual(resultPackageReusableDefaultSummary.reusable_default_ref, "default.continue.result.spine.job.commitment", "result package reusable default summary ref missing");
+    assert.strictEqual(resultPackageReusableDefaultSummary.default_followthrough.review_surface, "/v1/proof-center/result-package-handoff/review/default-continuation", "result package reusable default review surface missing");
+    assert.strictEqual(resultPackageReusableDefaultSummary.default_followthrough.reusable_by_default, true, "result package reusable default summary reusable-by-default missing");
+    const resultPackageReusableDefaultTemplate = await client.prepareInteractionResultPackageReusableDefaultTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-default-template"
+    });
+    assert.strictEqual(resultPackageReusableDefaultTemplate.reusable_default_ref, "default.continue.result.spine.job.commitment", "result package reusable default template ref missing");
+    assert.strictEqual(resultPackageReusableDefaultTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/default-continuation", "result package reusable default template target surface missing");
+    const resultPackageCompositionContractSummary = await client.prepareInteractionResultPackageCompositionContractSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-contract-summary"
+    });
+    assert.strictEqual(resultPackageCompositionContractSummary.composition_contract_ref, "contract.continue.result.spine.job.commitment", "result package composition contract summary ref missing");
+    assert.strictEqual(resultPackageCompositionContractSummary.next_surface, "/v1/proof-center/result-package-handoff/review/contract-summary", "result package composition contract summary next surface missing");
+    assert.strictEqual(resultPackageCompositionContractSummary.contract_ready, true, "result package composition contract summary contract-ready missing");
+    const resultPackageCompositionContractTemplate = await client.prepareInteractionResultPackageCompositionContractTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-contract-template"
+    });
+    assert.strictEqual(resultPackageCompositionContractTemplate.composition_contract_ref, "contract.continue.result.spine.job.commitment", "result package composition contract template ref missing");
+    assert.strictEqual(resultPackageCompositionContractTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/contract-summary", "result package composition contract template target surface missing");
+    const resultPackageCompositionContractBundle = await client.prepareInteractionResultPackageCompositionContractBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-contract-bundle"
+    });
+    assert.strictEqual(resultPackageCompositionContractBundle.composition_contract_summary.composition_contract_ref, "contract.continue.result.spine.job.commitment", "result package composition contract bundle summary ref missing");
+    assert.strictEqual(resultPackageCompositionContractBundle.composition_contract_template.target_surface, "/v1/proof-center/result-package-handoff/review/contract-summary", "result package composition contract bundle template target surface missing");
+    const resultPackageAdapterBridgeSummary = await client.prepareInteractionResultPackageAdapterBridgeSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-bridge-summary"
+    });
+    assert.strictEqual(resultPackageAdapterBridgeSummary.adapter_bridge_ref, "bridge.continue.result.spine.job.commitment", "result package adapter bridge summary ref missing");
+    assert.strictEqual(resultPackageAdapterBridgeSummary.next_surface, "/v1/proof-center/result-package-handoff/review/bridge-summary", "result package adapter bridge summary next surface missing");
+    assert.strictEqual(resultPackageAdapterBridgeSummary.bridge_ready, true, "result package adapter bridge summary bridge-ready missing");
+    const resultPackageAdapterBridgeTemplate = await client.prepareInteractionResultPackageAdapterBridgeTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-bridge-template"
+    });
+    assert.strictEqual(resultPackageAdapterBridgeTemplate.adapter_bridge_ref, "bridge.continue.result.spine.job.commitment", "result package adapter bridge template ref missing");
+    assert.strictEqual(resultPackageAdapterBridgeTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/bridge-summary", "result package adapter bridge template target surface missing");
+    const resultPackageAdapterBridgeBundle = await client.prepareInteractionResultPackageAdapterBridgeBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-bridge-bundle"
+    });
+    assert.strictEqual(resultPackageAdapterBridgeBundle.adapter_bridge_summary.adapter_bridge_ref, "bridge.continue.result.spine.job.commitment", "result package adapter bridge bundle summary ref missing");
+    assert.strictEqual(resultPackageAdapterBridgeBundle.adapter_bridge_template.target_surface, "/v1/proof-center/result-package-handoff/review/bridge-summary", "result package adapter bridge bundle template target surface missing");
+    const resultPackageAdapterBridgeCarry = await client.prepareInteractionResultPackageAdapterBridgeCarry("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-bridge-carry"
+    });
+    assert.strictEqual(resultPackageAdapterBridgeCarry.adapter_bridge_ref, "bridge.continue.result.spine.job.commitment", "result package adapter bridge carry ref missing");
+    assert.strictEqual(resultPackageAdapterBridgeCarry.stable_bridge_ids.includes("proof_run"), true, "result package adapter bridge carry ids missing");
+    assert.strictEqual(resultPackageAdapterBridgeCarry.review_surface, "/v1/proof-center/result-package-handoff/review/bridge-carry", "result package adapter bridge carry review surface missing");
+    const resultPackageHandoffSummary = await client.prepareInteractionResultPackageHandoffSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-summary"
+    });
+    assert.strictEqual(resultPackageHandoffSummary.handoff_contract_ref, "handoff.bridge.continue.result.spine.job.commitment", "result package handoff summary ref missing");
+    assert.strictEqual(resultPackageHandoffSummary.next_surface, "/v1/proof-center/result-package-handoff/review/handoff-continuity", "result package handoff summary next surface missing");
+    assert.strictEqual(resultPackageHandoffSummary.handoff_ready, true, "result package handoff summary handoff-ready missing");
+    const resultPackageHandoffTemplate = await client.prepareInteractionResultPackageHandoffTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-template"
+    });
+    assert.strictEqual(resultPackageHandoffTemplate.handoff_contract_ref, "handoff.bridge.continue.result.spine.job.commitment", "result package handoff template ref missing");
+    assert.strictEqual(resultPackageHandoffTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/handoff-continuity", "result package handoff template target surface missing");
+    const resultPackageHandoffBundle = await client.prepareInteractionResultPackageHandoffBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-bundle"
+    });
+    assert.strictEqual(resultPackageHandoffBundle.handoff_summary.handoff_contract_ref, "handoff.bridge.continue.result.spine.job.commitment", "result package handoff bundle summary ref missing");
+    assert.strictEqual(resultPackageHandoffBundle.handoff_template.target_surface, "/v1/proof-center/result-package-handoff/review/handoff-continuity", "result package handoff bundle template target surface missing");
+    const resultPackageHandoffCarry = await client.prepareInteractionResultPackageHandoffCarry("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-carry"
+    });
+    assert.strictEqual(resultPackageHandoffCarry.handoff_contract_ref, "handoff.bridge.continue.result.spine.job.commitment", "result package handoff carry ref missing");
+    assert.strictEqual(resultPackageHandoffCarry.stable_handoff_ids.includes("proof_run"), true, "result package handoff carry ids missing");
+    assert.strictEqual(resultPackageHandoffCarry.review_surface, "/v1/proof-center/result-package-handoff/review/handoff-run", "result package handoff carry review surface missing");
+    const resultPackageHandoffSurfaceSummary = await client.prepareInteractionResultPackageHandoffSurfaceSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-surface-summary"
+    });
+    assert.strictEqual(resultPackageHandoffSurfaceSummary.adapter_handoff_surface_ref, "surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff surface summary ref missing");
+    assert.strictEqual(resultPackageHandoffSurfaceSummary.next_surface, "/v1/proof-center/result-package-handoff/review/handoff-intake", "result package handoff surface summary next surface missing");
+    assert.strictEqual(resultPackageHandoffSurfaceSummary.adapter_consumable, true, "result package handoff surface summary consumable missing");
+    const resultPackageHandoffSurfaceTemplate = await client.prepareInteractionResultPackageHandoffSurfaceTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-surface-template"
+    });
+    assert.strictEqual(resultPackageHandoffSurfaceTemplate.adapter_handoff_surface_ref, "surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff surface template ref missing");
+    assert.strictEqual(resultPackageHandoffSurfaceTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/handoff-intake", "result package handoff surface template target surface missing");
+    const resultPackageHandoffSurfaceBundle = await client.prepareInteractionResultPackageHandoffSurfaceBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-surface-bundle"
+    });
+    assert.strictEqual(resultPackageHandoffSurfaceBundle.adapter_handoff_surface_summary.adapter_handoff_surface_ref, "surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff surface bundle summary ref missing");
+    assert.strictEqual(resultPackageHandoffSurfaceBundle.adapter_handoff_surface_template.target_surface, "/v1/proof-center/result-package-handoff/review/handoff-intake", "result package handoff surface bundle template target surface missing");
+    const resultPackageHandoffPackageSummary = await client.prepareInteractionResultPackageHandoffPackageSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-package-summary"
+    });
+    assert.strictEqual(resultPackageHandoffPackageSummary.adapter_handoff_package_ref, "package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff package summary ref missing");
+    assert.strictEqual(resultPackageHandoffPackageSummary.next_surface, "/v1/proof-center/result-package-handoff/review/handoff-package-intake", "result package handoff package summary next surface missing");
+    assert.strictEqual(resultPackageHandoffPackageSummary.adapter_usable, true, "result package handoff package summary usable missing");
+    const resultPackageHandoffPackageBundle = await client.prepareInteractionResultPackageHandoffPackageBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-package-bundle"
+    });
+    assert.strictEqual(resultPackageHandoffPackageBundle.adapter_handoff_package_summary.adapter_handoff_package_ref, "package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff package bundle summary ref missing");
+    assert.strictEqual(resultPackageHandoffPackageBundle.adapter_handoff_package_template.target_surface, "/v1/proof-center/result-package-handoff/review/handoff-package-intake", "result package handoff package bundle template target surface missing");
+    const resultPackageHandoffPackageDefaultSummary = await client.prepareInteractionResultPackageHandoffPackageDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-handoff-package-default-summary"
+    });
+    assert.strictEqual(resultPackageHandoffPackageDefaultSummary.default_handoff_package_ref, "default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package handoff package default summary ref missing");
+    assert.strictEqual(resultPackageHandoffPackageDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/handoff-package-run", "result package handoff package default summary next surface missing");
+    assert.strictEqual(resultPackageHandoffPackageDefaultSummary.package_usable_by_default, true, "result package handoff package default summary usable missing");
+    const resultPackageExecutionPackageSummary = await client.prepareInteractionResultPackageExecutionPackageSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-package-summary"
+    });
+    assert.strictEqual(resultPackageExecutionPackageSummary.execution_package_ref, "execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution package summary ref missing");
+    assert.strictEqual(resultPackageExecutionPackageSummary.next_surface, "/v1/proof-center/result-package-handoff/review/execution-package", "result package execution package summary next surface missing");
+    assert.strictEqual(resultPackageExecutionPackageSummary.adapter_ready, true, "result package execution package summary ready missing");
+    const resultPackageExecutionPackageBundle = await client.prepareInteractionResultPackageExecutionPackageBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-package-bundle"
+    });
+    assert.strictEqual(resultPackageExecutionPackageBundle.execution_package_summary.execution_package_ref, "execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution package bundle summary ref missing");
+    assert.strictEqual(resultPackageExecutionPackageBundle.execution_package_template.target_surface, "/v1/proof-center/result-package-handoff/review/execution-package", "result package execution package bundle template target surface missing");
+    const resultPackageExecutionPackageDefaultSummary = await client.prepareInteractionResultPackageExecutionPackageDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-package-default-summary"
+    });
+    assert.strictEqual(resultPackageExecutionPackageDefaultSummary.default_execution_package_ref, "default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution package default summary ref missing");
+    assert.strictEqual(resultPackageExecutionPackageDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/execution-package-run", "result package execution package default summary next surface missing");
+    assert.strictEqual(resultPackageExecutionPackageDefaultSummary.execution_ready_by_default, true, "result package execution package default summary ready missing");
+    const resultPackageExecutionContractSummary = await client.prepareInteractionResultPackageExecutionContractSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-contract-summary"
+    });
+    assert.strictEqual(resultPackageExecutionContractSummary.execution_contract_ref, "contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution contract summary ref missing");
+    assert.strictEqual(resultPackageExecutionContractSummary.next_surface, "/v1/proof-center/result-package-handoff/review/execution-contract", "result package execution contract summary next surface missing");
+    assert.strictEqual(resultPackageExecutionContractSummary.adapter_operable, true, "result package execution contract summary operable missing");
+    const resultPackageExecutionContractBundle = await client.prepareInteractionResultPackageExecutionContractBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-contract-bundle"
+    });
+    assert.strictEqual(resultPackageExecutionContractBundle.execution_contract_summary.execution_contract_ref, "contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution contract bundle summary ref missing");
+    assert.strictEqual(resultPackageExecutionContractBundle.execution_contract_template.target_surface, "/v1/proof-center/result-package-handoff/review/execution-contract", "result package execution contract bundle template target surface missing");
+    const resultPackageExecutionContractDefaultSummary = await client.prepareInteractionResultPackageExecutionContractDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-execution-contract-default-summary"
+    });
+    assert.strictEqual(resultPackageExecutionContractDefaultSummary.default_execution_contract_ref, "default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package execution contract default summary ref missing");
+    assert.strictEqual(resultPackageExecutionContractDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/execution-contract-run", "result package execution contract default summary next surface missing");
+    assert.strictEqual(resultPackageExecutionContractDefaultSummary.execution_operable_by_default, true, "result package execution contract default summary operable missing");
+    const resultPackageOperatingContractSummary = await client.prepareInteractionResultPackageOperatingContractSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-contract-summary"
+    });
+    assert.strictEqual(resultPackageOperatingContractSummary.operating_contract_ref, "operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating contract summary ref missing");
+    assert.strictEqual(resultPackageOperatingContractSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-contract", "result package operating contract summary next surface missing");
+    assert.strictEqual(resultPackageOperatingContractSummary.adapter_stable, true, "result package operating contract summary stable missing");
+    const resultPackageOperatingContractBundle = await client.prepareInteractionResultPackageOperatingContractBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-contract-bundle"
+    });
+    assert.strictEqual(resultPackageOperatingContractBundle.operating_contract_summary.operating_contract_ref, "operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating contract bundle summary ref missing");
+    assert.strictEqual(resultPackageOperatingContractBundle.operating_contract_template.target_surface, "/v1/proof-center/result-package-handoff/review/operating-contract", "result package operating contract bundle template target surface missing");
+    const resultPackageOperatingContractDefaultSummary = await client.prepareInteractionResultPackageOperatingContractDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-contract-default-summary"
+    });
+    assert.strictEqual(resultPackageOperatingContractDefaultSummary.default_operating_contract_ref, "default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating contract default summary ref missing");
+    assert.strictEqual(resultPackageOperatingContractDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-contract-run", "result package operating contract default summary next surface missing");
+    assert.strictEqual(resultPackageOperatingContractDefaultSummary.operating_stable_by_default, true, "result package operating contract default summary stable missing");
+    const resultPackageOperatingInterfaceSummary = await client.prepareInteractionResultPackageOperatingInterfaceSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-interface-summary"
+    });
+    assert.strictEqual(resultPackageOperatingInterfaceSummary.operating_interface_ref, "interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating interface summary ref missing");
+    assert.strictEqual(resultPackageOperatingInterfaceSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-interface", "result package operating interface summary next surface missing");
+    assert.strictEqual(resultPackageOperatingInterfaceSummary.adapter_reliable, true, "result package operating interface summary reliable missing");
+    const resultPackageOperatingInterfaceBundle = await client.prepareInteractionResultPackageOperatingInterfaceBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-interface-bundle"
+    });
+    assert.strictEqual(resultPackageOperatingInterfaceBundle.operating_interface_summary.operating_interface_ref, "interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating interface bundle summary ref missing");
+    assert.strictEqual(resultPackageOperatingInterfaceBundle.operating_interface_template.target_surface, "/v1/proof-center/result-package-handoff/review/operating-interface", "result package operating interface bundle template target surface missing");
+    const resultPackageOperatingInterfaceDefaultSummary = await client.prepareInteractionResultPackageOperatingInterfaceDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-interface-default-summary"
+    });
+    assert.strictEqual(resultPackageOperatingInterfaceDefaultSummary.default_operating_interface_ref, "default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating interface default summary ref missing");
+    assert.strictEqual(resultPackageOperatingInterfaceDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-interface-run", "result package operating interface default summary next surface missing");
+    assert.strictEqual(resultPackageOperatingInterfaceDefaultSummary.operating_interface_reliable_by_default, true, "result package operating interface default summary reliable missing");
+    const resultPackageOperatingIntegrationSummary = await client.prepareInteractionResultPackageOperatingIntegrationSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-integration-summary"
+    });
+    assert.strictEqual(resultPackageOperatingIntegrationSummary.operating_integration_ref, "integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating integration summary ref missing");
+    assert.strictEqual(resultPackageOperatingIntegrationSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-integration", "result package operating integration summary next surface missing");
+    assert.strictEqual(resultPackageOperatingIntegrationSummary.adapter_integrable, true, "result package operating integration summary integrable missing");
+    const resultPackageOperatingIntegrationBundle = await client.prepareInteractionResultPackageOperatingIntegrationBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-integration-bundle"
+    });
+    assert.strictEqual(resultPackageOperatingIntegrationBundle.operating_integration_summary.operating_integration_ref, "integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating integration bundle summary ref missing");
+    assert.strictEqual(resultPackageOperatingIntegrationBundle.operating_integration_template.target_surface, "/v1/proof-center/result-package-handoff/review/operating-integration", "result package operating integration bundle template target surface missing");
+    const resultPackageOperatingIntegrationDefaultSummary = await client.prepareInteractionResultPackageOperatingIntegrationDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-integration-default-summary"
+    });
+    assert.strictEqual(resultPackageOperatingIntegrationDefaultSummary.default_operating_integration_ref, "default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating integration default summary ref missing");
+    assert.strictEqual(resultPackageOperatingIntegrationDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-integration-run", "result package operating integration default summary next surface missing");
+    assert.strictEqual(resultPackageOperatingIntegrationDefaultSummary.operating_integration_integrable_by_default, true, "result package operating integration default summary integrable missing");
+    const resultPackageOperatingPathSummary = await client.prepareInteractionResultPackageOperatingPathSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-path-summary"
+    });
+    assert.strictEqual(resultPackageOperatingPathSummary.operating_path_ref, "path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating path summary ref missing");
+    assert.strictEqual(resultPackageOperatingPathSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-path", "result package operating path summary next surface missing");
+    assert.strictEqual(resultPackageOperatingPathSummary.adapter_ready_by_default, true, "result package operating path summary default readiness missing");
+    const resultPackageOperatingPathBundle = await client.prepareInteractionResultPackageOperatingPathBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-path-bundle"
+    });
+    assert.strictEqual(resultPackageOperatingPathBundle.operating_path_summary.operating_path_ref, "path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating path bundle summary ref missing");
+    assert.strictEqual(resultPackageOperatingPathBundle.operating_path_template.target_surface, "/v1/proof-center/result-package-handoff/review/operating-path", "result package operating path bundle template target surface missing");
+    const resultPackageOperatingPathDefaultSummary = await client.prepareInteractionResultPackageOperatingPathDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-operating-path-default-summary"
+    });
+    assert.strictEqual(resultPackageOperatingPathDefaultSummary.default_operating_path_ref, "default.path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package operating path default summary ref missing");
+    assert.strictEqual(resultPackageOperatingPathDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/operating-path-run", "result package operating path default summary next surface missing");
+    assert.strictEqual(resultPackageOperatingPathDefaultSummary.operating_path_ready_by_default, true, "result package operating path default summary ready missing");
+    const resultPackageCompleteDefaultPathSummary = await client.prepareInteractionResultPackageCompleteDefaultPathSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-complete-default-path-summary"
+    });
+    assert.strictEqual(resultPackageCompleteDefaultPathSummary.complete_default_path_ref, "complete.default.path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package complete default path summary ref missing");
+    assert.strictEqual(resultPackageCompleteDefaultPathSummary.next_surface, "/v1/proof-center/result-package-handoff/review/complete-default-path", "result package complete default path summary next surface missing");
+    assert.strictEqual(resultPackageCompleteDefaultPathSummary.adapter_complete_by_default, true, "result package complete default path summary complete missing");
+    const resultPackageCompleteDefaultPathBundle = await client.prepareInteractionResultPackageCompleteDefaultPathBundle("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-complete-default-path-bundle"
+    });
+    assert.strictEqual(resultPackageCompleteDefaultPathBundle.complete_default_path_summary.complete_default_path_ref, "complete.default.path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package complete default path bundle summary ref missing");
+    assert.strictEqual(resultPackageCompleteDefaultPathBundle.complete_default_path_template.target_surface, "/v1/proof-center/result-package-handoff/review/complete-default-path", "result package complete default path bundle template target surface missing");
+    const resultPackageCompleteDefaultPathDefaultSummary = await client.prepareInteractionResultPackageCompleteDefaultPathDefaultSummary("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-complete-default-path-default-summary"
+    });
+    assert.strictEqual(resultPackageCompleteDefaultPathDefaultSummary.default_complete_default_path_ref, "default.complete.default.path.default.integration.default.interface.default.operating.default.contract.default.execution.default.package.surface.handoff.bridge.continue.result.spine.job.commitment", "result package complete default path default summary ref missing");
+    assert.strictEqual(resultPackageCompleteDefaultPathDefaultSummary.next_surface, "/v1/proof-center/result-package-handoff/review/complete-default-path-run", "result package complete default path default summary next surface missing");
+    assert.strictEqual(resultPackageCompleteDefaultPathDefaultSummary.complete_default_path_ready, true, "result package complete default path default summary ready missing");
+    const resultPackageExtensionTemplate = await client.prepareInteractionResultPackageExtensionTemplate("continue.result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-quickstart-12",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-continuation-extension-template"
+    });
+    assert.strictEqual(resultPackageExtensionTemplate.extension_seam_ref, "extension.continue.result.spine.job.commitment", "result package extension template seam ref missing");
+    assert.strictEqual(resultPackageExtensionTemplate.target_surface, "/v1/proof-center/result-package-handoff/review/extension-readiness", "result package extension template target surface missing");
+    const explicitStagedPartnerQuote = await client.createTaskSetQuote([
+      {
+        task_ref: "adapter.mcp.invoke",
+        body: {
+          tool_name: "summarize",
+          arguments: { text: "explicit-staged-partner-selection" }
+        }
+      }
+    ], {
+      command: "quickstart-explicit-staged-partner-quote",
+      protocol: "mcp",
+      integrationId: "partner.protocol.acme_mcp",
+      integrationIds: ["partner.protocol.acme_mcp", "builtin.settlement.chain"],
+      settlementMode: "evm_payment"
+    });
+    assert.strictEqual(
+      explicitStagedPartnerQuote.quote.integration_ids.includes("partner.protocol.acme_mcp"),
+      true,
+      "explicit staged partner quote missing requested integration"
+    );
+    assert.strictEqual(
+      explicitStagedPartnerQuote.quote.integration_ids.includes("builtin.settlement.chain"),
+      true,
+      "explicit staged partner quote missing settlement integration"
+    );
+    const trustTasks = await client.findTasks({ category: "trust", query: "verify" }, true);
+    assert.strictEqual(trustTasks.length >= 1, true, "filtered task discovery missing");
+    const trustTaskSummaries = await client.findTaskSummaries({ category: "trust", query: "verify" }, true);
+    assert.strictEqual(trustTaskSummaries.task_count >= 1, true, "filtered task summaries missing");
+    const taskCategories = await client.listTaskCategories(true);
+    assert.strictEqual(taskCategories.length >= 1, true, "task category list missing");
+    assert.strictEqual(taskCategories.includes("runtime"), true, "runtime task category missing");
+    assert.strictEqual(taskCategories.includes("admission"), true, "admission task category missing");
+    assert.strictEqual(taskCategories.includes("a2a"), true, "a2a task category missing");
+    assert.strictEqual(taskCategories.includes("a2c"), true, "a2c task category missing");
+    assert.strictEqual(taskCategories.includes("identity"), true, "identity task category missing");
+    const taskCategorySummaries = await client.getTaskCategorySummaries(true);
+    assert.strictEqual(taskCategorySummaries.category_count >= 1, true, "task category summaries missing");
+    const taskCapabilities = await client.listCapabilities(true);
+    assert.strictEqual(taskCapabilities.length >= 1, true, "capability list missing");
+    assert.strictEqual(taskCapabilities.includes("runtime.emit_anchor"), true, "runtime capability missing");
+    const capabilitySummaries = await client.getCapabilitySummaries(true);
+    assert.strictEqual(capabilitySummaries.capability_count >= 1, true, "capability summaries missing");
+    const taskAdapters = await client.listAdapters(true);
+    assert.strictEqual(taskAdapters.length >= 1, true, "adapter list missing");
+    assert.strictEqual(taskAdapters.includes("mcp"), true, "mcp adapter missing");
+    const adapterSummaries = await client.getAdapterSummaries(true);
+    assert.strictEqual(adapterSummaries.adapter_count >= 1, true, "adapter summaries missing");
+    const taskExecutionModes = await client.listTaskExecutionModes(true);
+    assert.strictEqual(taskExecutionModes.length >= 1, true, "task execution mode list missing");
+    const taskExecutionModeSummaries = await client.getTaskExecutionModeSummaries(true);
+    assert.strictEqual(taskExecutionModeSummaries.execution_mode_count >= 1, true, "task execution mode summaries missing");
+    const taskPricingBands = await client.listTaskPricingBands(true);
+    assert.strictEqual(taskPricingBands.length >= 1, true, "task pricing band list missing");
+    const taskPricingBandSummaries = await client.getTaskPricingBandSummaries(true);
+    assert.strictEqual(taskPricingBandSummaries.pricing_band_count >= 1, true, "task pricing band summaries missing");
+    const taskPricingCurrencies = await client.listTaskPricingCurrencies(true);
+    assert.strictEqual(taskPricingCurrencies.length >= 1, true, "task pricing currency list missing");
+    const taskPricingCurrencySummaries = await client.getTaskPricingCurrencySummaries(true);
+    assert.strictEqual(taskPricingCurrencySummaries.pricing_currency_count >= 1, true, "task pricing currency summaries missing");
+    const taskLatencyClasses = await client.listTaskLatencyClasses(true);
+    assert.strictEqual(taskLatencyClasses.length >= 1, true, "task latency class list missing");
+    const taskLatencySummaries = await client.getTaskLatencySummaries(true);
+    assert.strictEqual(taskLatencySummaries.latency_class_count >= 1, true, "task latency summaries missing");
+    const taskFailurePostures = await client.listTaskFailurePostures(true);
+    assert.strictEqual(taskFailurePostures.length >= 1, true, "task failure posture list missing");
+    const taskFailurePostureSummaries = await client.getTaskFailurePostureSummaries(true);
+    assert.strictEqual(taskFailurePostureSummaries.failure_posture_count >= 1, true, "task failure posture summaries missing");
+    const trustTaskSummary = await client.getTaskSummary("trust.verify", true);
+    assert.strictEqual(trustTaskSummary.task_ref, "trust.verify", "task summary missing");
+    const rawTasks = await client.getTasks(["trust.verify", "settlement.submit"], true);
+    assert.strictEqual(rawTasks.length, 2, "raw task batch lookup missing");
+    const taskSummaries = await client.getTaskSummaries(["trust.verify", "settlement.submit"], true);
+    assert.strictEqual(taskSummaries.task_count, 2, "task summaries missing");
+    const normalizedTaskSummaries = await client.getTaskSummaries([" trust.verify ", "", "settlement.submit "], true);
+    assert.deepStrictEqual(normalizedTaskSummaries.task_refs, ["trust.verify", "settlement.submit"], "task summary ref normalization missing");
+    const settlementProfiles = await client.findSettlementProfiles({ mode: "evm_payment", query: "USDC" }, true);
+    assert.strictEqual(settlementProfiles.length >= 1, true, "filtered settlement discovery missing");
+    const settlementProfilesSummary = await client.getSettlementProfilesSummary(true);
+    assert.strictEqual(settlementProfilesSummary.settlement_profile_count >= 1, true, "settlement profile summary missing");
+    assert.strictEqual(settlementProfilesSummary.settlement_profile_count >= 5, true, "canonical settlement breadth missing");
+    assert.strictEqual(Array.isArray(settlementProfilesSummary.settlement_profile_keys), true, "settlement profile summary keys missing");
+    const settlementModeSummaries = await client.getSettlementModeSummaries(true);
+    assert.strictEqual(settlementModeSummaries.settlement_mode_count >= 1, true, "settlement mode summaries missing");
+    const settlementModes = await client.listSettlementModes(true);
+    assert.strictEqual(settlementModes.length >= 1, true, "settlement mode list missing");
+    assert.strictEqual(settlementModes.includes("bsv_teranode"), true, "bsv settlement mode missing");
+    assert.strictEqual(settlementModes.includes("solana_payment"), true, "solana settlement mode missing");
+    const settlementAssetSummaries = await client.getSettlementAssetSummaries(true);
+    assert.strictEqual(settlementAssetSummaries.settlement_asset_count >= 1, true, "settlement asset summaries missing");
+    const settlementAssets = await client.listSettlementAssets(true);
+    assert.strictEqual(settlementAssets.length >= 1, true, "settlement asset list missing");
+    const settlementAdapterSummaries = await client.getSettlementAdapterSummaries(true);
+    assert.strictEqual(settlementAdapterSummaries.settlement_adapter_count >= 1, true, "settlement adapter summaries missing");
+    const settlementAdapters = await client.listSettlementAdapters(true);
+    assert.strictEqual(settlementAdapters.length >= 1, true, "settlement adapter list missing");
+    const settlementRequiredInputSummaries = await client.getSettlementRequiredInputSummaries(true);
+    assert.strictEqual(settlementRequiredInputSummaries.settlement_required_input_count >= 1, true, "settlement required input summaries missing");
+    const settlementRequiredInputs = await client.listSettlementRequiredInputs(true);
+    assert.strictEqual(settlementRequiredInputs.length >= 1, true, "settlement required input list missing");
+    const settlementPayeeSummaries = await client.getSettlementPayeeSummaries(true);
+    assert.strictEqual(settlementPayeeSummaries.settlement_payee_count >= 1, true, "settlement payee summaries missing");
+    const settlementPayees = await client.listSettlementPayees(true);
+    assert.strictEqual(settlementPayees.length >= 1, true, "settlement payee list missing");
+    const settlementPricingUnitSummaries = await client.getSettlementPricingUnitSummaries(true);
+    assert.strictEqual(settlementPricingUnitSummaries.settlement_pricing_unit_count >= 1, true, "settlement pricing unit summaries missing");
+    const settlementPricingUnits = await client.listSettlementPricingUnits(true);
+    assert.strictEqual(settlementPricingUnits.length >= 1, true, "settlement pricing unit list missing");
+    const sampleSettlementPayee = settlementPayeeSummaries.settlement_payees[0] && settlementPayeeSummaries.settlement_payees[0].payee_agent_id;
+    const settlementProfilesByPayee = await client.findSettlementProfiles({ payee_agent_id: sampleSettlementPayee }, true);
+    assert.strictEqual(settlementProfilesByPayee.length >= 1, true, "settlement payee filter missing");
+    const sampleSettlementRequiredInput = settlementRequiredInputSummaries.settlement_required_inputs[0] && settlementRequiredInputSummaries.settlement_required_inputs[0].field;
+    const settlementProfilesByRequiredInput = await client.findSettlementProfiles({ required_input: sampleSettlementRequiredInput }, true);
+    assert.strictEqual(settlementProfilesByRequiredInput.length >= 1, true, "settlement required input filter missing");
+    const settlementProfileSummaries = await client.findSettlementProfileSummaries({ mode: "evm_payment", query: "USDC" }, true);
+    assert.strictEqual(settlementProfileSummaries.settlement_profile_count >= 1, true, "filtered settlement summaries missing");
+
+    const workflowCatalog = await client.fetchWorkflowCatalog(true);
+    assert.strictEqual(Array.isArray(workflowCatalog.workflows), true, "workflow catalog missing");
+    const workflowCatalogSummary = await client.fetchWorkflowCatalogSummary(true);
+    assert.strictEqual(workflowCatalogSummary.workflow_count >= 1, true, "workflow catalog summary missing");
+    assert.strictEqual(Array.isArray(workflowCatalogSummary.workflow_refs), true, "workflow catalog summary refs missing");
+    assert.strictEqual(workflowCatalogSummary.workflow_refs.includes("runtime.consequence.flow"), true, "runtime workflow missing");
+    assert.strictEqual(workflowCatalogSummary.workflow_refs.includes("a2c.tooling.flow"), true, "a2c workflow missing");
+    assert.strictEqual(workflowCatalogSummary.workflow_refs.includes("registry.pack.anchor.flow"), true, "registry pack workflow missing");
+    const governedWorkflows = await client.findWorkflows({ latency_class: "governed_async", task_ref: "settlement.submit" }, true);
+    assert.strictEqual(governedWorkflows.length >= 1, true, "filtered workflow discovery missing");
+    const governedWorkflowSummaries = await client.findWorkflowSummaries({ latency_class: "governed_async", task_ref: "settlement.submit" }, true);
+    assert.strictEqual(governedWorkflowSummaries.workflow_count >= 1, true, "filtered workflow summaries missing");
+    const workflows = await client.getWorkflows(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflows.length, 2, "workflow batch lookup missing");
+    const workflowSummary = await client.getWorkflowSummary("policy.transaction.flow", true);
+    assert.strictEqual(workflowSummary.workflow_ref, "policy.transaction.flow", "workflow summary missing");
+    const workflowSummaries = await client.getWorkflowSummaries(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowSummaries.workflow_count, 2, "workflow summaries missing");
+    const normalizedWorkflowSummaries = await client.getWorkflowSummaries([" policy.transaction.flow ", "", "trust.flow "], true);
+    assert.deepStrictEqual(normalizedWorkflowSummaries.workflow_refs, ["policy.transaction.flow", "trust.flow"], "workflow summary ref normalization missing");
+    const workflowCategories = await client.listWorkflowCategories(true);
+    assert.strictEqual(workflowCategories.length >= 1, true, "workflow category list missing");
+    const workflowCategorySummaries = await client.getWorkflowCategorySummaries(true);
+    assert.strictEqual(workflowCategorySummaries.category_count >= 1, true, "workflow category summaries missing");
+    const workflowCapabilities = await client.listWorkflowCapabilities(true);
+    assert.strictEqual(workflowCapabilities.length >= 1, true, "workflow capability list missing");
+    const workflowCapabilitySummaries = await client.getWorkflowCapabilitySummaries(true);
+    assert.strictEqual(workflowCapabilitySummaries.capability_count >= 1, true, "workflow capability summaries missing");
+    const workflowExecutionModes = await client.listWorkflowExecutionModes(true);
+    assert.strictEqual(workflowExecutionModes.length >= 1, true, "workflow execution mode list missing");
+    const workflowExecutionModeSummaries = await client.getWorkflowExecutionModeSummaries(true);
+    assert.strictEqual(workflowExecutionModeSummaries.execution_mode_count >= 1, true, "workflow execution mode summaries missing");
+    const workflowPricingBands = await client.listWorkflowPricingBands(true);
+    assert.strictEqual(workflowPricingBands.length >= 1, true, "workflow pricing band list missing");
+    const workflowPricingBandSummaries = await client.getWorkflowPricingBandSummaries(true);
+    assert.strictEqual(workflowPricingBandSummaries.pricing_band_count >= 1, true, "workflow pricing band summaries missing");
+    const workflowPricingCurrencies = await client.listWorkflowPricingCurrencies(true);
+    assert.strictEqual(workflowPricingCurrencies.length >= 1, true, "workflow pricing currency list missing");
+    const workflowPricingCurrencySummaries = await client.getWorkflowPricingCurrencySummaries(true);
+    assert.strictEqual(workflowPricingCurrencySummaries.pricing_currency_count >= 1, true, "workflow pricing currency summaries missing");
+    const workflowAdapters = await client.listWorkflowAdapters(true);
+    assert.strictEqual(workflowAdapters.length >= 1, true, "workflow adapter list missing");
+    const workflowAdapterSummaries = await client.getWorkflowAdapterSummaries(true);
+    assert.strictEqual(workflowAdapterSummaries.adapter_count >= 1, true, "workflow adapter summaries missing");
+    const workflowLatencyClasses = await client.listWorkflowLatencyClasses(true);
+    assert.strictEqual(workflowLatencyClasses.length >= 1, true, "workflow latency class list missing");
+    const workflowLatencySummaries = await client.getWorkflowLatencySummaries(true);
+    assert.strictEqual(workflowLatencySummaries.latency_class_count >= 1, true, "workflow latency summaries missing");
+    const workflowFailurePostures = await client.listWorkflowFailurePostures(true);
+    assert.strictEqual(workflowFailurePostures.length >= 1, true, "workflow failure posture list missing");
+    const workflowFailurePostureSummaries = await client.getWorkflowFailurePostureSummaries(true);
+    assert.strictEqual(workflowFailurePostureSummaries.failure_posture_count >= 1, true, "workflow failure posture summaries missing");
+    const workflowPricingBases = await client.listWorkflowPricingBases(true);
+    assert.strictEqual(workflowPricingBases.length >= 1, true, "workflow pricing basis list missing");
+    const workflowPricingBasisSummaries = await client.getWorkflowPricingBasisSummaries(true);
+    assert.strictEqual(workflowPricingBasisSummaries.pricing_basis_count >= 1, true, "workflow pricing basis summaries missing");
+    const sampleWorkflowPricingBasis = workflowPricingBasisSummaries.pricing_bases[0] && workflowPricingBasisSummaries.pricing_bases[0].pricing_basis;
+    const workflowsByPricingBasis = await client.findWorkflows({ pricing_basis: sampleWorkflowPricingBasis }, true);
+    assert.strictEqual(workflowsByPricingBasis.length >= 1, true, "workflow pricing basis filter missing");
+    const sampleWorkflowCapability = workflowCapabilitySummaries.capabilities[0] && workflowCapabilitySummaries.capabilities[0].capability;
+    const workflowsByCapability = await client.findWorkflows({ capability: sampleWorkflowCapability }, true);
+    assert.strictEqual(workflowsByCapability.length >= 1, true, "workflow capability filter missing");
+    const sampleWorkflowPricingCurrency = workflowPricingCurrencySummaries.pricing_currencies[0] && workflowPricingCurrencySummaries.pricing_currencies[0].currency;
+    const workflowsByPricingCurrency = await client.findWorkflows({ pricing_currency: sampleWorkflowPricingCurrency }, true);
+    assert.strictEqual(workflowsByPricingCurrency.length >= 1, true, "workflow pricing currency filter missing");
+    const taskPricingSummary = await client.getTaskPricingSummary("trust.verify", true);
+    assert.strictEqual(taskPricingSummary.task_ref, "trust.verify", "task pricing summary missing");
+    const taskPricing = await client.getTaskPricing("trust.verify", true);
+    assert.strictEqual(taskPricing.task_ref, "trust.verify", "task pricing missing");
+    const taskPricingSummaries = await client.getTaskPricingSummaries(["trust.verify", "policy.simulate"], true);
+    assert.strictEqual(taskPricingSummaries.task_count, 2, "task pricing summaries missing");
+    assert.strictEqual(Array.isArray(taskPricingSummaries.task_refs), true, "task pricing summary refs missing");
+    const workflowPricingSummary = await client.getWorkflowPricingSummary("policy.transaction.flow", true);
+    assert.strictEqual(workflowPricingSummary.workflow_ref, "policy.transaction.flow", "workflow pricing summary missing");
+    const workflowPricing = await client.getWorkflowPricing("policy.transaction.flow", true);
+    assert.strictEqual(workflowPricing.workflow_ref, "policy.transaction.flow", "workflow pricing missing");
+    const workflowPricingSummaries = await client.getWorkflowPricingSummaries(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowPricingSummaries.workflow_count, 2, "workflow pricing summaries missing");
+    assert.strictEqual(Array.isArray(workflowPricingSummaries.workflow_refs), true, "workflow pricing summary refs missing");
+    const taskSchemaSummary = await client.getTaskSchemaSummary("trust.verify", true);
+    assert.strictEqual(taskSchemaSummary.task_ref, "trust.verify", "task schema summary missing");
+    const taskSchema = await client.getTaskSchema("trust.verify", true);
+    assert.strictEqual(taskSchema.type, "object", "task schema missing");
+    const taskSchemaSummaries = await client.getTaskSchemaSummaries(["trust.verify", "settlement.submit"], true);
+    assert.strictEqual(taskSchemaSummaries.task_count, 2, "task schema summaries missing");
+    assert.strictEqual(Array.isArray(taskSchemaSummaries.task_refs), true, "task schema summary refs missing");
+    const workflowSchema = await client.getWorkflowSchema("policy.transaction.flow", true);
+    assert.strictEqual(workflowSchema.task_count, 2, "workflow schema missing");
+    const workflowSchemaSummary = await client.getWorkflowSchemaSummary("policy.transaction.flow", true);
+    assert.strictEqual(workflowSchemaSummary.task_count, 2, "workflow schema summary missing");
+    const workflowSchemas = await client.getWorkflowSchemas(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowSchemas.workflow_count, 2, "workflow schemas missing");
+    const workflowSchemaSummaries = await client.getWorkflowSchemaSummaries(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowSchemaSummaries.workflow_count, 2, "workflow schema summaries missing");
+    assert.strictEqual(Array.isArray(workflowSchemaSummaries.workflow_refs), true, "workflow schema summary refs missing");
+    const taskTemplateSummary = await client.getTaskTemplateSummary("trust.verify", true);
+    assert.strictEqual(taskTemplateSummary.task_ref, "trust.verify", "task template summary missing");
+    const taskTemplate = await client.getTaskTemplate("trust.verify", true);
+    assert.strictEqual(typeof taskTemplate, "object", "task template missing");
+    const taskTemplateSummaries = await client.getTaskTemplateSummaries(["trust.verify", "settlement.submit"], true);
+    assert.strictEqual(taskTemplateSummaries.task_count, 2, "task template summaries missing");
+    assert.strictEqual(Array.isArray(taskTemplateSummaries.task_refs), true, "task template summary refs missing");
+    const workflowTemplate = await client.getWorkflowTemplate("policy.transaction.flow", true);
+    assert.strictEqual(workflowTemplate.task_count, 2, "workflow template missing");
+    assert.strictEqual(Array.isArray(workflowTemplate.tasks), true, "workflow template tasks missing");
+    const workflowTemplateSummary = await client.getWorkflowTemplateSummary("policy.transaction.flow", true);
+    assert.strictEqual(workflowTemplateSummary.task_count, 2, "workflow template summary missing");
+    const workflowTemplates = await client.getWorkflowTemplates(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowTemplates.length, 2, "workflow templates missing");
+    const workflowTemplateSummaries = await client.getWorkflowTemplateSummaries(["policy.transaction.flow", "trust.flow"], true);
+    assert.strictEqual(workflowTemplateSummaries.workflow_count, 2, "workflow template summaries missing");
+    assert.strictEqual(Array.isArray(workflowTemplateSummaries.workflow_refs), true, "workflow template summary refs missing");
+    const taskBodyValidationSummary = await client.validateTaskBodySummary("trust.verify", { subject_id: "subject-valid" }, true);
+    assert.strictEqual(taskBodyValidationSummary.ok, true, "task body validation summary missing");
+    const taskSetValidationSummary = await client.validateTaskSetSummary([
+      { task_ref: "trust.verify", body: { subject_id: "subject-valid" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-valid" } }
+    ], true);
+    assert.strictEqual(taskSetValidationSummary.ok, true, "task set validation summary missing");
+    const taskSetValidationSummaries = await client.validateTaskSetSummaries([
+      {
+        task_set_id: "trust_validation_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-valid-batch" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-valid-batch" } }
+        ],
+        options: {
+          forceRefreshCatalog: true
+        }
+      },
+      {
+        task_set_id: "policy_validation_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-valid-batch" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-valid-batch" } }
+        ],
+        options: {
+          forceRefreshCatalog: true
+        }
+      }
+    ], { forceRefreshCatalog: true });
+    assert.strictEqual(taskSetValidationSummaries.task_set_count, 2, "task set validation summaries missing");
+    const workflowValidationSummary = await client.validateWorkflowTaskSetSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-valid" },
+      "settlement.submit": { intent_id: "intent-valid" }
+    }, { forceRefreshCatalog: true });
+    assert.strictEqual(workflowValidationSummary.ok, true, "workflow task-set validation summary missing");
+    const workflowValidationSummaries = await client.validateWorkflowTaskSetsSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-valid-batch" },
+          "settlement.submit": { intent_id: "intent-valid-batch" }
+        },
+        options: {
+          forceRefreshCatalog: true
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-valid-batch" },
+          "receipt.validate": { receipt_id: "rcpt-valid-batch" }
+        },
+        options: {
+          forceRefreshCatalog: true
+        }
+      }
+    ], { forceRefreshCatalog: true });
+    assert.strictEqual(workflowValidationSummaries.workflow_count, 2, "workflow task-set validation summaries missing");
+    const ensuredWorkflowTaskSet = await client.ensureWorkflowTaskSetValid("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-valid" },
+      "settlement.submit": { intent_id: "intent-valid" }
+    }, { forceRefreshCatalog: true });
+    assert.strictEqual(ensuredWorkflowTaskSet.length, 2, "workflow task-set ensure missing");
+    const ensuredWorkflowTaskSets = await client.ensureWorkflowTaskSetsValid([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-valid-batch-ensure" },
+          "settlement.submit": { intent_id: "intent-valid-batch-ensure" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-valid-batch-ensure" },
+          "receipt.validate": { receipt_id: "rcpt-valid-batch-ensure" }
+        }
+      }
+    ], { forceRefreshCatalog: true });
+    assert.strictEqual(ensuredWorkflowTaskSets.length, 2, "workflow task-set batch ensure missing");
+    const ensuredTaskSets = await client.ensureTaskSetsValid([
+      {
+        task_set_id: "trust_validation_ensure_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-valid-batch-ensure" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-valid-batch-ensure" } }
+        ],
+        options: {
+          forceRefreshCatalog: true
+        }
+      },
+      {
+        task_set_id: "policy_validation_ensure_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-valid-batch-ensure" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-valid-batch-ensure" } }
+        ],
+        options: {
+          forceRefreshCatalog: true
+        }
+      }
+    ], { forceRefreshCatalog: true });
+    assert.strictEqual(ensuredTaskSets.length, 2, "task-set batch ensure missing");
+    const executionValidationSummary = await client.validateExecutionPayloadSummary({
+      command: "quickstart-validate",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-valid" }
+    }, true);
+    assert.strictEqual(executionValidationSummary.ok, true, "execution validation summary missing");
+    const workflowPreview = await client.previewWorkflowQuote("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-preview" },
+      "settlement.submit": { intent_id: "intent-preview" }
+    }, {
+      command: "quickstart-workflow-preview"
+    });
+    assert.strictEqual(client.summarizeQuotePreview(workflowPreview).quote.task_count, 2, "workflow preview missing");
+    const workflowPreviewSummary = await client.previewWorkflowQuoteSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-preview" },
+      "settlement.submit": { intent_id: "intent-preview" }
+    }, {
+      command: "quickstart-workflow-preview"
+    });
+    assert.strictEqual(workflowPreviewSummary.quote.task_count, 2, "workflow preview summary missing");
+    const workflowPreviewSummaries = await client.previewWorkflowQuoteSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-preview-batch" },
+          "settlement.submit": { intent_id: "intent-preview-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-preview-batch-a"
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-preview-batch" },
+          "receipt.validate": { receipt_id: "rcpt-preview-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-preview-batch-b"
+        }
+      }
+    ], {
+      command: "quickstart-workflow-preview-batch"
+    });
+    assert.strictEqual(workflowPreviewSummaries.workflow_count, 2, "workflow preview summaries missing");
+    const workflowPreviewBatch = await client.previewWorkflowQuotes([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-preview-raw-batch" },
+          "settlement.submit": { intent_id: "intent-preview-raw-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-preview-raw-batch-a"
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-preview-raw-batch" },
+          "receipt.validate": { receipt_id: "rcpt-preview-raw-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-preview-raw-batch-b"
+        }
+      }
+    ]);
+    assert.strictEqual(workflowPreviewBatch.length, 2, "workflow preview batch missing");
+    assert.strictEqual(workflowPreviewBatch[0].preview.quote.task_count >= 1, true, "workflow preview batch preview missing");
+    const taskSetPreview = await client.previewTaskSetQuote([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-preview" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-preview" } }
+    ], {
+      command: "quickstart-task-set-preview"
+    });
+    assert.strictEqual(client.summarizeQuotePreview(taskSetPreview).quote.task_count, 2, "task-set preview missing");
+    const taskSetPreviewSummary = await client.previewTaskSetQuoteSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-preview-summary" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-preview-summary" } }
+    ], {
+      command: "quickstart-task-set-preview-summary"
+    });
+    assert.strictEqual(taskSetPreviewSummary.quote.task_count, 2, "task-set preview summary missing");
+    const taskSetPreviewSummaries = await client.previewTaskSetQuoteSummaries([
+      {
+        task_set_id: "policy_set_preview_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-preview-batch" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-preview-batch" } }
+        ],
+        options: {
+          command: "quickstart-task-set-preview-batch"
+        }
+      },
+      {
+        task_set_id: "trust_set_preview_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-preview-batch" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-preview-batch" } }
+        ],
+        options: {
+          command: "quickstart-task-set-preview-batch-trust"
+        }
+      }
+    ]);
+    assert.strictEqual(taskSetPreviewSummaries.task_set_count, 2, "task-set preview summaries missing");
+    const taskSetPreviewBatch = await client.previewTaskSetQuotes([
+      {
+        task_set_id: "policy_set_preview_raw_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-preview-raw-batch" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-preview-raw-batch" } }
+        ]
+      },
+      {
+        task_set_id: "trust_set_preview_raw_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-preview-raw-batch" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-preview-raw-batch" } }
+        ]
+      }
+    ]);
+    assert.strictEqual(taskSetPreviewBatch.length, 2, "task-set preview batch missing");
+    assert.strictEqual(taskSetPreviewBatch[0].preview.quote.task_count >= 1, true, "task-set preview batch preview missing");
+    const workflowQuote = await client.createWorkflowQuote("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-workflow-quote" },
+      "settlement.submit": { intent_id: "intent-workflow-quote" }
+    }, {
+      command: "quickstart-workflow-quote"
+    });
+    assert.strictEqual(workflowQuote.quote.task_count, 2, "workflow quote missing");
+    const workflowQuoteSummary = await client.createWorkflowQuoteSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-workflow-quote-summary" },
+      "settlement.submit": { intent_id: "intent-workflow-quote-summary" }
+    }, {
+      command: "quickstart-workflow-quote-summary"
+    });
+    assert.strictEqual(workflowQuoteSummary.task_count, 2, "workflow quote summary missing");
+    const workflowQuoteSummaries = await client.createWorkflowQuoteSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-workflow-quote-batch" },
+          "settlement.submit": { intent_id: "intent-workflow-quote-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-quote-batch-a"
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-workflow-quote-batch" },
+          "receipt.validate": { receipt_id: "rcpt-workflow-quote-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-quote-batch-b"
+        }
+      }
+    ], {
+      command: "quickstart-workflow-quote-batch"
+    });
+    assert.strictEqual(workflowQuoteSummaries.workflow_count, 2, "workflow quote summaries missing");
+    const workflowQuoteBatch = await client.createWorkflowQuotes([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-workflow-quote-raw-batch" },
+          "settlement.submit": { intent_id: "intent-workflow-quote-raw-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-quote-raw-batch-a"
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-workflow-quote-raw-batch" },
+          "receipt.validate": { receipt_id: "rcpt-workflow-quote-raw-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-quote-raw-batch-b"
+        }
+      }
+    ]);
+    assert.strictEqual(workflowQuoteBatch.length, 2, "workflow quote batch missing");
+    assert.strictEqual(workflowQuoteBatch[0].quote.quote.task_count >= 1, true, "workflow quote batch quote missing");
+    const taskSetQuote = await client.createTaskSetQuote([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-quote" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-quote" } }
+    ], {
+      command: "quickstart-task-set-quote"
+    });
+    assert.strictEqual(taskSetQuote.quote.task_count, 2, "task-set quote missing");
+    const taskSetQuoteSummary = await client.createTaskSetQuoteSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-quote-summary" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-quote-summary" } }
+    ], {
+      command: "quickstart-task-set-quote-summary"
+    });
+    assert.strictEqual(taskSetQuoteSummary.task_count, 2, "task-set quote summary missing");
+    const taskSetQuoteSummaries = await client.createTaskSetQuoteSummaries([
+      {
+        task_set_id: "policy_set_quote_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-quote-batch" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-quote-batch" } }
+        ],
+        options: {
+          command: "quickstart-task-set-quote-batch"
+        }
+      },
+      {
+        task_set_id: "trust_set_quote_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-quote-batch" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-quote-batch" } }
+        ],
+        options: {
+          command: "quickstart-task-set-quote-batch-trust"
+        }
+      }
+    ]);
+    assert.strictEqual(taskSetQuoteSummaries.task_set_count, 2, "task-set quote summaries missing");
+    const taskSetQuoteBatch = await client.createTaskSetQuotes([
+      {
+        task_set_id: "policy_set_quote_raw_batch",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-quote-raw-batch" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-quote-raw-batch" } }
+        ]
+      },
+      {
+        task_set_id: "trust_set_quote_raw_batch",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-quote-raw-batch" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-quote-raw-batch" } }
+        ]
+      }
+    ]);
+    assert.strictEqual(taskSetQuoteBatch.length, 2, "task-set quote batch missing");
+    assert.strictEqual(taskSetQuoteBatch[0].quote.quote.task_count >= 1, true, "task-set quote batch quote missing");
+    const workflowExecutionSummary = await client.executeWorkflowSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-summary" },
+      "settlement.submit": { intent_id: "intent-summary" }
+    }, {
+      command: "quickstart-workflow-summary"
+    });
+    assert.strictEqual(workflowExecutionSummary.transaction.task_count >= 1, true, "workflow execution summary missing");
+    const workflowExecutionSummaries = await client.executeWorkflowSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-summary-batch" },
+          "settlement.submit": { intent_id: "intent-summary-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-summary-batch-a"
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-summary-batch" },
+          "receipt.validate": { receipt_id: "rcpt-summary-batch" }
+        },
+        options: {
+          command: "quickstart-workflow-summary-batch-b"
+        }
+      }
+    ], {
+      command: "quickstart-workflow-summary-batch"
+    });
+    assert.strictEqual(workflowExecutionSummaries.workflow_count, 2, "workflow execution summaries missing");
+
+    const quote = await client.createExecutionQuote({
+      command: "quickstart",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-1" }
+    });
+    assert.strictEqual(typeof quote.quote.quote_id, "string", "quote missing id");
+    assert.strictEqual(quote.quote.payment.status, "quoted", "quote payment status missing");
+    assert.strictEqual(typeof quote.quote.settlement.binding_hash, "string", "quote settlement binding hash missing");
+    assert.strictEqual(quote.quote.treasury.status, "pending_payment", "quote treasury status missing");
+    assert.strictEqual(typeof quote.quote.default_path.path_kind, "string", "quote default path kind missing");
+    assert.strictEqual(typeof quote.quote.default_path.treasury_destination_id, "string", "quote default path treasury destination missing");
+    const genericQuoteSummary = await client.createPaymentQuoteSummary({
+      command: "quickstart-generic-quote-summary",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-generic-quote-summary" }
+    });
+    assert.strictEqual(genericQuoteSummary.task_count >= 1, true, "generic quote summary missing");
+    const quoteSummary = await client.createExecutionQuoteSummary({
+      command: "quickstart-summary-quote",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-quote-summary" }
+    });
+    assert.strictEqual(quoteSummary.task_count >= 1, true, "execution quote summary missing");
+    const quoteDetail = await client.getPaymentQuote(quote.quote.quote_id);
+    assert.strictEqual(quoteDetail.quote.status, "quoted", "quote detail missing");
+    const nativePreview = await client.previewExecutionQuote({
+      command: "quickstart-preview",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-preview-1" }
+    });
+    assert.strictEqual(client.summarizeQuotePreview(nativePreview).quote.task_count >= 1, true, "native preview missing");
+    const nativePreviewSummary = await client.previewExecutionQuoteSummary({
+      command: "quickstart-preview",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-preview-1" }
+    });
+    assert.strictEqual(nativePreviewSummary.quote.task_count >= 1, true, "native preview summary missing");
+    const executionSummary = await client.executeSummary({
+      command: "quickstart-summary",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-summary" }
+    });
+    assert.strictEqual(executionSummary.transaction.transaction_id !== null, true, "execution summary missing");
+    const settledExecutionSummary = await client.executeAndWaitSummary({
+      command: "quickstart-summary-wait",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-summary-wait" }
+    }, {
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionSummary.delivery_status, "delivered", "execution wait summary missing");
+    const settledExecutionActivitySummary = await client.executeAndWaitActivitySummary({
+      command: "quickstart-summary-wait-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-summary-wait-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionActivitySummary.delivery_count >= 1, true, "execution wait activity summary missing");
+    const settledExecutionMonitorSnapshot = await client.executeAndWaitMonitorSnapshot({
+      command: "quickstart-summary-wait-monitor-snapshot",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-summary-wait-monitor-snapshot" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionMonitorSnapshot.transaction.status, "completed", "execution wait monitor snapshot missing");
+    const settledExecutionMonitorSummary = await client.executeAndWaitMonitorSummary({
+      command: "quickstart-summary-wait-monitor",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-summary-wait-monitor" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionMonitorSummary.status, "completed", "execution wait monitor summary missing");
+    const settledExecutionLinkedSummary = await client.executeAndWaitLinkedRecordSummary({
+      command: "quickstart-summary-wait-linked",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-summary-wait-linked" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionLinkedSummary.delivery_count >= 1, true, "execution wait linked summary missing");
+    const settledExecutionLinkedActivitySummary = await client.executeAndWaitLinkedRecordActivitySummary({
+      command: "quickstart-summary-wait-linked-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-summary-wait-linked-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledExecutionLinkedActivitySummary.transaction_count >= 1, true, "execution wait linked activity summary missing");
+    const settledNativeExecutionSummary = await client.executeNativeAndWaitSummary({
+      command: "quickstart-native-summary-wait",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-native-summary-wait" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionSummary.delivery_status, "delivered", "native execution wait summary missing");
+    const settledNativeExecutionActivitySummary = await client.executeNativeAndWaitActivitySummary({
+      command: "quickstart-native-summary-wait-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-native-wait-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionActivitySummary.delivery_count >= 1, true, "native execution wait activity summary missing");
+    const settledNativeExecutionMonitorSnapshot = await client.executeNativeAndWaitMonitorSnapshot({
+      command: "quickstart-native-summary-wait-monitor-snapshot",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-native-wait-monitor-snapshot" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionMonitorSnapshot.transaction.status, "completed", "native execution wait monitor snapshot missing");
+    const settledNativeExecutionMonitorSummary = await client.executeNativeAndWaitMonitorSummary({
+      command: "quickstart-native-summary-wait-monitor",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-native-wait-monitor" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionMonitorSummary.status, "completed", "native execution wait monitor summary missing");
+    const settledNativeExecutionLinkedSummary = await client.executeNativeAndWaitLinkedRecordSummary({
+      command: "quickstart-native-summary-wait-linked",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-native-wait-linked" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionLinkedSummary.delivery_count >= 1, true, "native execution wait linked summary missing");
+    const settledNativeExecutionLinkedActivitySummary = await client.executeNativeAndWaitLinkedRecordActivitySummary({
+      command: "quickstart-native-summary-wait-linked-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-native-wait-linked-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledNativeExecutionLinkedActivitySummary.transaction_count >= 1, true, "native execution wait linked activity summary missing");
+    const instantPreview = await client.previewExecutionQuote({
+      command: "quickstart-preview-instant",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-preview-2" }
+    }, {
+      instant: true
+    });
+    assert.strictEqual(client.summarizeQuotePreview(instantPreview).payment_required, true, "instant preview missing");
+    const instantPreviewSummary = await client.previewExecutionQuoteSummary({
+      command: "quickstart-preview-instant",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-preview-2" }
+    }, {
+      instant: true
+    });
+    assert.strictEqual(instantPreviewSummary.payment_required, true, "instant preview summary missing");
+
+    const result = await client.execute({
+      command: "quickstart",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-1" }
+    });
+    assert.strictEqual(typeof result.transaction.transaction_id, "string", "transaction missing");
+    assert.strictEqual(typeof result.receipt.receipt_id, "string", "receipt missing");
+    assert.strictEqual(result.transaction.payment.status, "recorded", "transaction payment status missing");
+    assert.strictEqual(typeof result.transaction.settlement.settlement_id, "string", "transaction settlement id missing");
+    assert.strictEqual(typeof result.transaction.treasury.destination_id, "string", "transaction treasury destination missing");
+    assert.strictEqual(result.transaction.default_path.status, "recorded", "transaction default path status missing");
+    assert.strictEqual(result.receipt.payment.payment_id, result.transaction.payment.payment_id, "receipt payment linkage missing");
+    assert.strictEqual(result.receipt.settlement.settlement_id, result.transaction.settlement.settlement_id, "receipt settlement linkage missing");
+    assert.strictEqual(result.receipt.treasury.payment_id, result.transaction.payment.payment_id, "receipt treasury linkage missing");
+    assert.strictEqual(result.receipt.default_path.path_kind, result.transaction.default_path.path_kind, "receipt default path linkage missing");
+    const creditPackSummary = await client.getCreditPackSummary();
+    assert.strictEqual(creditPackSummary.credit_pack_ids.includes("credits.agent"), true, "credit pack summary missing agent pack");
+    const creditGrant = await client.createExternalCreditGrant({
+      grant_id: "quickstart_credit_grant_1",
+      account_id: "acct_demo",
+      pack_id: "credits.agent"
+    });
+    assert.strictEqual(creditGrant.grant_id, "quickstart_credit_grant_1", "credit grant missing");
+    assert.strictEqual(typeof creditGrant.entitlement.entitlement_id, "string", "credit grant entitlement missing");
+    const creditBalance = await client.getCreditBalance("acct_demo");
+    assert.strictEqual(creditBalance.available_units >= 1, true, "credit balance missing");
+    assert.strictEqual(creditBalance.entitlement_summary.entitlement_count >= 1, true, "credit balance entitlement summary missing");
+    const usageMeterPreview = await client.previewUsageMetering({
+      account_id: "acct_demo",
+      task_ref: "trust.verify"
+    });
+    assert.strictEqual(usageMeterPreview.pricing_band, "trust_critical", "usage meter preview pricing band missing");
+    const usageMeteringSummaryInitial = await client.getUsageMeteringSummary("acct_demo");
+    assert.strictEqual(usageMeteringSummaryInitial.usage_meter_count, 0, "usage meter summary should start empty");
+    const entitlementSummary = await client.getEntitlementSummary("acct_demo");
+    assert.strictEqual(entitlementSummary.entitlement_count >= 1, true, "entitlement summary missing");
+    const entitlements = await client.listEntitlements("acct_demo");
+    assert.strictEqual(entitlements.entitlements.length >= 1, true, "entitlement list missing");
+    const entitlementDetail = await client.getEntitlement(creditGrant.entitlement.entitlement_id, "acct_demo");
+    assert.strictEqual(entitlementDetail.entitlement_id, creditGrant.entitlement.entitlement_id, "entitlement detail missing");
+    const entitlementReplenishmentSummary = await client.getEntitlementReplenishmentSummary("acct_demo");
+    assert.strictEqual(entitlementReplenishmentSummary.entitlement_count >= 1, true, "entitlement replenishment summary missing");
+    const entitlementReplenishmentView = await client.getEntitlementReplenishmentView(creditGrant.entitlement.entitlement_id, "acct_demo");
+    assert.strictEqual(typeof entitlementReplenishmentView.low_balance_state, "string", "entitlement replenishment view missing");
+    const updatedReplenishmentPreference = await client.updateEntitlementReplenishmentPreference(
+      creditGrant.entitlement.entitlement_id,
+      {
+        low_balance_threshold_units: 100,
+        preferred_replacement_pack_id: "credits.topup"
+      },
+      "acct_demo"
+    );
+    assert.strictEqual(updatedReplenishmentPreference.replenishment_view.recommended_replenishment_pack_id, "credits.topup", "entitlement replenishment preference missing");
+    const creditPolicyPack = await client.getCreditSpendPolicyPack("acct_demo");
+    assert.strictEqual(creditPolicyPack.default_spend_posture, "open_spend", "credit policy pack default posture missing");
+    const creditPreview = await client.previewCreditSpend({
+      account_id: "acct_demo",
+      task_ref: "trust.verify",
+      units: 1
+    });
+    assert.strictEqual(creditPreview.spend_posture, "open_spend", "credit preview spend posture missing");
+    assert.strictEqual(creditPreview.credit_spend_preview.executable_now, true, "credit preview should be executable");
+    const creditFirstResult = await client.executeWithCreditsFirst({
+      command: "quickstart-credits-first",
+      account_id: "acct_demo",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-credits-1" }
+    });
+    assert.strictEqual(creditFirstResult.transaction.credit_spend.units >= 1, true, "credits-first spend linkage missing");
+    assert.strictEqual(typeof creditFirstResult.transaction.credit_spend.usage_meter_id, "string", "credits-first usage meter missing");
+    const spendCredential = await client.createSpendCredential({
+      credential_id: "quickstart_spend_credential_1",
+      account_id: "acct_demo"
+    });
+    assert.strictEqual(spendCredential.credential_id, "quickstart_spend_credential_1", "spend credential create missing");
+    const delegatedCreditResult = await client.executeWithSpendCredential({
+      payment_preference: "credits_first",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-credits-2" }
+    }, {
+      spendToken: spendCredential.bearer_token
+    });
+    assert.strictEqual(delegatedCreditResult.transaction.credit_spend.units >= 1, true, "delegated spend execution missing");
+    const poolBoundSpendCredential = await client.createSpendCredential({
+      credential_id: "quickstart_spend_credential_pool_1",
+      account_id: "acct_demo",
+      entitlement_id: creditGrant.entitlement.entitlement_id
+    });
+    assert.strictEqual(poolBoundSpendCredential.effective_pool_binding_mode, "entitlement_bound", "pool-bound spend credential mode missing");
+    const poolBoundDelegatedResult = await client.executeWithSpendCredential({
+      payment_preference: "credits_first",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-credits-3" }
+    }, {
+      spendToken: poolBoundSpendCredential.bearer_token
+    });
+    assert.strictEqual(poolBoundDelegatedResult.transaction.credit_spend.entitlement_id, creditGrant.entitlement.entitlement_id, "pool-bound delegated entitlement missing");
+    const usageMeters = await client.listUsageMeters("acct_demo");
+    assert.strictEqual(usageMeters.usage_meters.length >= 3, true, "usage meter list missing");
+    const usageMeterDetail = await client.getUsageMeter(creditFirstResult.transaction.credit_spend.usage_meter_id, "acct_demo");
+    assert.strictEqual(usageMeterDetail.usage_meter_id, creditFirstResult.transaction.credit_spend.usage_meter_id, "usage meter detail missing");
+    const usageMeteringSummary = await client.getUsageMeteringSummary("acct_demo");
+    assert.strictEqual(usageMeteringSummary.usage_meter_count >= 3, true, "usage meter summary missing");
+    const economicConsequenceHandoffBundle = await client.exportEconomicConsequenceHandoffBundle({
+      account_id: "acct_demo",
+      usage_meter_id: creditFirstResult.transaction.credit_spend.usage_meter_id,
+      credit_spend_id: creditFirstResult.transaction.credit_spend.credit_spend_id
+    });
+    assert.strictEqual(economicConsequenceHandoffBundle.handoff_bundle.contract_version, "naxytra-economic-consequence-handoff-v1", "economic consequence handoff bundle version missing");
+    const creditGrantForResultExport = await client.createExternalCreditGrant({
+      grant_id: "quickstart_credit_grant_export_1",
+      account_id: "acct_demo",
+      pack_id: "credits.topup",
+      purchase_reference: "purchase-export-topup-1"
+    });
+    assert.strictEqual(creditGrantForResultExport.pack_id, "credits.topup", "credit grant export topup pack missing");
+    const creditFirstResultPackageExport = await client.exportInteractionResultPackage("result.spine.job.commitment", {
+      payment_preference: "credits_first",
+      account_id: "acct_demo",
+      quoted_units: 2,
+      job_type: "batch.render",
+      job_id: "job-quickstart-credit-export-1",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "quickstart-result-package-export-credit-first"
+    });
+    assert.strictEqual(
+      creditFirstResultPackageExport.economic_consequence_handoff_bundle.contract_version,
+      "naxytra-economic-consequence-handoff-v1",
+      "credit-first result package export should auto-carry the economic consequence bundle"
+    );
+    assert.strictEqual(
+      creditFirstResultPackageExport.portable_handoff_bundle.economic_consequence_handoff_bundle.usage_meter_ref,
+      creditFirstResultPackageExport.economic_consequence_handoff_bundle.usage_meter_ref,
+      "portable handoff bundle economic carry missing"
+    );
+    const linkedResultSet = await client.getLinkedRecordSet(result);
+    assert.strictEqual(linkedResultSet.quote.quote_id, result.transaction.quote_id, "linked quote missing");
+    assert.strictEqual(linkedResultSet.payment_ledger.length >= 1, true, "linked payment ledger missing");
+    assert.strictEqual(linkedResultSet.deliveries.length >= 1, true, "linked deliveries missing");
+    const linkedActivity = await client.getLinkedRecordActivitySnapshot(result);
+    const linkedActivitySummary = client.summarizeLinkedRecordActivitySnapshot(linkedActivity);
+    assert.strictEqual(linkedActivitySummary.quote_count >= 1, true, "linked activity snapshot missing");
+    assert.strictEqual(typeof linkedActivitySummary.refs.quote_id, "string", "linked activity refs missing");
+    const linkedActivitySummaryDirect = await client.getLinkedRecordActivitySummary(result);
+    assert.strictEqual(linkedActivitySummaryDirect.quote_count >= 1, true, "linked activity summary helper missing");
+    const linkedSummaryFromResult = await client.getLinkedRecordSummary(result);
+    assert.strictEqual(linkedSummaryFromResult.delivery_count >= 1, true, "linked record summary helper missing");
+    const linkedResultSummary = client.summarizeLinkedRecordSet(linkedResultSet);
+    assert.strictEqual(linkedResultSummary.delivery_count >= 1, true, "linked record summary missing");
+    const executedQuote = await client.getPaymentQuote(result.transaction.quote_id);
+    assert.strictEqual(executedQuote.quote.status, "executed", "executed quote detail missing");
+    assert.strictEqual(executedQuote.quote.payment.status, "recorded", "executed quote payment status missing");
+    assert.strictEqual(executedQuote.quote.settlement.status, "recorded", "executed quote settlement status missing");
+    assert.strictEqual(executedQuote.quote.treasury.status, "recorded", "executed quote treasury status missing");
+    assert.strictEqual(executedQuote.quote.default_path.status, "recorded", "executed quote default path status missing");
+    const executedQuoteSummary = await client.getPaymentQuoteSummary(result.transaction.quote_id);
+    assert.strictEqual(executedQuoteSummary.status, "executed", "executed quote summary missing");
+    const quoteSummaries = await client.listPaymentQuoteSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(quoteSummaries.quote_count >= 1, true, "quote summaries missing");
+    assert.strictEqual(Array.isArray(quoteSummaries.quote_ids), true, "quote summary ids missing");
+    const quoteIds = await client.listPaymentQuoteIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(quoteIds.length >= 1, true, "quote id list missing");
+    const quoteStatuses = await client.listPaymentQuoteStatuses({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(quoteStatuses.length >= 1, true, "quote status list missing");
+    const quoteStatusSummaries = await client.getPaymentQuoteStatusSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(quoteStatusSummaries.status_count >= 1, true, "quote status summaries missing");
+    const quoteCurrencies = await client.listPaymentQuoteCurrencies({ transaction_id: result.transaction.transaction_id });
+    const filteredQuotesByCurrency = await client.listPaymentQuotes({ transaction_id: result.transaction.transaction_id, currency: quoteCurrencies[0] });
+    assert.strictEqual(Array.isArray(filteredQuotesByCurrency.quotes), true, "quote currency filter missing");
+    const transactions = await client.listTransactions({ status: "completed", account_id: "acct_demo" });
+    assert.strictEqual(Array.isArray(transactions.transactions), true, "transaction list missing");
+    const transactionSummary = await client.getTransactionSummary(result.transaction.transaction_id);
+    assert.strictEqual(transactionSummary.transaction_id, result.transaction.transaction_id, "transaction summary helper missing");
+    const transactionSummaries = await client.listTransactionSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(transactionSummaries.transaction_count >= 1, true, "transaction summaries missing");
+    assert.strictEqual(Array.isArray(transactionSummaries.transaction_ids), true, "transaction summary ids missing");
+    const transactionIds = await client.listTransactionIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(transactionIds.length >= 1, true, "transaction id list missing");
+    const transactionStatuses = await client.listTransactionStatuses({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(transactionStatuses.length >= 1, true, "transaction status list missing");
+    const transactionStatusSummaries = await client.getTransactionStatusSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(transactionStatusSummaries.status_count >= 1, true, "transaction status summaries missing");
+    const transactionCurrencies = await client.listTransactionCurrencies({ transaction_id: result.transaction.transaction_id });
+    const filteredTransactionsByCurrency = await client.listTransactions({ transaction_id: result.transaction.transaction_id, currency: transactionCurrencies[0] });
+    assert.strictEqual(Array.isArray(filteredTransactionsByCurrency.transactions), true, "transaction currency filter missing");
+    const receipts = await client.listReceipts({ status: "completed", transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(Array.isArray(receipts.receipts), true, "receipt list missing");
+    const receiptSummary = await client.getReceiptSummary(result.receipt.receipt_id);
+    assert.strictEqual(receiptSummary.receipt_id, result.receipt.receipt_id, "receipt summary helper missing");
+    const receiptSummaries = await client.listReceiptSummaries({ status: "completed", transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(receiptSummaries.receipt_count >= 1, true, "receipt summaries missing");
+    assert.strictEqual(Array.isArray(receiptSummaries.receipt_ids), true, "receipt summary ids missing");
+    const receiptIds = await client.listReceiptIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(receiptIds.length >= 1, true, "receipt id list missing");
+    const receiptStatuses = await client.listReceiptStatuses({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(receiptStatuses.length >= 1, true, "receipt status list missing");
+    const receiptCurrencies = await client.listReceiptCurrencies({ transaction_id: result.transaction.transaction_id });
+    const filteredReceiptsByCurrency = await client.listReceipts({ transaction_id: result.transaction.transaction_id, currency: receiptCurrencies[0] });
+    assert.strictEqual(Array.isArray(filteredReceiptsByCurrency.receipts), true, "receipt currency filter missing");
+    const paymentLedger = await client.listPaymentLedger({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(Array.isArray(paymentLedger.payment_ledger), true, "payment ledger missing");
+    const paymentEntry = await client.getPaymentLedgerEntry(paymentLedger.payment_ledger[0].payment_id);
+    assert.strictEqual(paymentEntry.payment.transaction_id, result.transaction.transaction_id, "payment ledger detail missing");
+    assert.strictEqual(paymentEntry.payment.payment.status, "recorded", "payment ledger payment object missing");
+    assert.strictEqual(typeof paymentEntry.payment.settlement.settlement_id, "string", "payment ledger settlement object missing");
+    assert.strictEqual(typeof paymentEntry.payment.treasury.destination_id, "string", "payment ledger treasury object missing");
+    assert.strictEqual(paymentEntry.payment.default_path.status, "recorded", "payment ledger default path status missing");
+    const paymentSummary = client.summarizePaymentLedgerEntry(paymentEntry);
+    assert.strictEqual(paymentSummary.payment_id, paymentEntry.payment.payment_id, "payment summary missing");
+    const paymentSummaryDirect = await client.getPaymentLedgerEntrySummary(paymentEntry.payment.payment_id);
+    assert.strictEqual(paymentSummaryDirect.payment_id, paymentEntry.payment.payment_id, "payment summary helper missing");
+    const paymentSummaries = await client.listPaymentLedgerSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(paymentSummaries.payment_ledger_count >= 1, true, "payment summaries missing");
+    assert.strictEqual(Array.isArray(paymentSummaries.payment_ids), true, "payment summary ids missing");
+    const paymentIds = await client.listPaymentIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(paymentIds.length >= 1, true, "payment id list missing");
+    const paymentCurrencies = await client.listPaymentCurrencies({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(paymentCurrencies.length >= 1, true, "payment currency list missing");
+    const deliveries = await client.listDeliveries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(Array.isArray(deliveries.deliveries), true, "delivery list missing");
+    const delivery = await client.getDelivery(deliveries.deliveries[0].delivery_id);
+    assert.strictEqual(delivery.delivery.transaction_id, result.transaction.transaction_id, "delivery detail missing");
+    assert.strictEqual(Array.isArray(delivery.delivery.history), true, "delivery history missing");
+    const deliverySummary = client.summarizeDelivery(delivery);
+    assert.strictEqual(deliverySummary.transaction_id, result.transaction.transaction_id, "delivery summary missing");
+    const deliverySummaryDirect = await client.getDeliverySummary(delivery.delivery.delivery_id);
+    assert.strictEqual(deliverySummaryDirect.delivery_id, delivery.delivery.delivery_id, "delivery summary helper missing");
+    const deliverySummaries = await client.listDeliverySummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(deliverySummaries.delivery_count >= 1, true, "delivery summaries missing");
+    assert.strictEqual(Array.isArray(deliverySummaries.delivery_ids), true, "delivery summary ids missing");
+    const deliveryIds = await client.listDeliveryIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(deliveryIds.length >= 1, true, "delivery id list missing");
+    const deliveryStatuses = await client.listDeliveryStatuses({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(deliveryStatuses.length >= 1, true, "delivery status list missing");
+    const filteredDeliveriesByTarget = await client.listDeliveries({ transaction_id: result.transaction.transaction_id, delivery_target_kind: "callback" });
+    assert.strictEqual(Array.isArray(filteredDeliveriesByTarget.deliveries), true, "delivery target filter missing");
+    const disputeSummary = await client.createDisputeSummary({
+      transaction_id: result.transaction.transaction_id,
+      receipt_id: result.receipt.receipt_id,
+      title: "Delivery mismatch",
+      reason_code: "delivery_mismatch",
+      note: "Need review"
+    });
+    assert.strictEqual(typeof disputeSummary.dispute_id, "string", "dispute summary missing id");
+    const reviewedDisputeSummary = await client.actOnDisputeSummary(disputeSummary.dispute_id, {
+      action: "review",
+      actor: { type: "operator", role: "reviewer" }
+    });
+    assert.strictEqual(reviewedDisputeSummary.status, "under_review", "dispute action summary missing");
+    const resolvedDispute = await client.actOnDispute(disputeSummary.dispute_id, {
+      action: "resolve",
+      resolution_code: "validated"
+    });
+    assert.strictEqual(resolvedDispute.dispute.status, "resolved", "dispute resolution missing");
+    const disputeActivity = await client.getDisputeActivitySnapshot(disputeSummary.dispute_id);
+    const disputeActivitySummary = client.summarizeActivitySnapshot(disputeActivity);
+    assert.strictEqual(disputeActivitySummary.dispute_count >= 1, true, "dispute activity snapshot missing");
+    const disputeActivitySummaryDirect = await client.getDisputeActivitySummary(disputeSummary.dispute_id);
+    assert.strictEqual(disputeActivitySummaryDirect.dispute_count >= 1, true, "dispute activity summary helper missing");
+    const disputeSummaryDirect = await client.getDisputeSummary(disputeSummary.dispute_id);
+    assert.strictEqual(disputeSummaryDirect.dispute_id, disputeSummary.dispute_id, "dispute summary helper missing");
+    const disputeList = await client.listDisputes({ transaction_id: result.transaction.transaction_id, status: "under_review" });
+    assert.strictEqual(Array.isArray(disputeList.disputes), true, "dispute list missing");
+    const disputeSummaries = await client.listDisputeSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(disputeSummaries.dispute_count >= 1, true, "dispute summaries missing");
+    assert.strictEqual(Array.isArray(disputeSummaries.dispute_ids), true, "dispute summary ids missing");
+    const disputeIds = await client.listDisputeIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(disputeIds.length >= 1, true, "dispute id list missing");
+    const disputeReasonCodes = await client.listDisputeReasonCodes({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(disputeReasonCodes.length >= 1, true, "dispute reason code list missing");
+    const filteredDisputesByTitle = await client.listDisputes({ transaction_id: result.transaction.transaction_id, title: "Delivery mismatch" });
+    assert.strictEqual(Array.isArray(filteredDisputesByTitle.disputes), true, "dispute title filter missing");
+    const settledDispute = await client.waitForDispute(disputeSummary.dispute_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(client.summarizeDispute(settledDispute).status, "resolved", "dispute summary missing");
+    const settledDisputeSummary = await client.waitForDisputeSummary(disputeSummary.dispute_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(settledDisputeSummary.status, "resolved", "dispute wait summary missing");
+    const refundSummary = await client.createRefundSummary({
+      transaction_id: result.transaction.transaction_id,
+      receipt_id: result.receipt.receipt_id,
+      reason_code: "policy_exception",
+      note: "Refund requested"
+    });
+    assert.strictEqual(typeof refundSummary.refund_id, "string", "refund summary missing id");
+    const reviewedRefundSummary = await client.actOnRefundSummary(refundSummary.refund_id, {
+      action: "review"
+    });
+    assert.strictEqual(reviewedRefundSummary.status, "under_review", "refund review summary missing");
+    const approvedRefundSummary = await client.actOnRefundSummary(refundSummary.refund_id, {
+      action: "approve",
+      action_code: "manual_refund"
+    });
+    assert.strictEqual(approvedRefundSummary.status, "approved", "refund action summary missing");
+    const completedRefund = await client.actOnRefund(refundSummary.refund_id, {
+      action: "complete",
+      action_code: "manual_refund"
+    });
+    assert.strictEqual(completedRefund.refund.status, "completed", "refund completion missing");
+    const refundActivity = await client.getRefundActivitySnapshot(refundSummary.refund_id);
+    const refundActivitySummary = client.summarizeActivitySnapshot(refundActivity);
+    assert.strictEqual(refundActivitySummary.refund_count >= 1, true, "refund activity snapshot missing");
+    const refundActivitySummaryDirect = await client.getRefundActivitySummary(refundSummary.refund_id);
+    assert.strictEqual(refundActivitySummaryDirect.refund_count >= 1, true, "refund activity summary helper missing");
+    const refundSummaryDirect = await client.getRefundSummary(refundSummary.refund_id);
+    assert.strictEqual(refundSummaryDirect.refund_id, refundSummary.refund_id, "refund summary helper missing");
+    const refundList = await client.listRefunds({ transaction_id: result.transaction.transaction_id, status: "approved" });
+    assert.strictEqual(Array.isArray(refundList.refunds), true, "refund list missing");
+    const refundSummaries = await client.listRefundSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(refundSummaries.refund_count >= 1, true, "refund summaries missing");
+    assert.strictEqual(Array.isArray(refundSummaries.refund_ids), true, "refund summary ids missing");
+    const refundIds = await client.listRefundIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(refundIds.length >= 1, true, "refund id list missing");
+    const refundStatuses = await client.listRefundStatuses({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(refundStatuses.length >= 1, true, "refund status list missing");
+    const refundStatusSummaries = await client.getRefundStatusSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(refundStatusSummaries.status_count >= 1, true, "refund status summaries missing");
+    const filteredRefundsByTitle = await client.listRefunds({ transaction_id: result.transaction.transaction_id, title: "Refund requested" });
+    assert.strictEqual(Array.isArray(filteredRefundsByTitle.refunds), true, "refund title filter missing");
+    const settledRefund = await client.waitForRefund(refundSummary.refund_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(client.summarizeRefund(settledRefund).status, "completed", "refund summary missing");
+    const settledRefundSummary = await client.waitForRefundSummary(refundSummary.refund_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(settledRefundSummary.status, "completed", "refund wait summary missing");
+    const remediationTicketSummary = await client.createRemediationTicketSummary({
+      transaction_id: result.transaction.transaction_id,
+      receipt_id: result.receipt.receipt_id,
+      reason_code: "manual_review",
+      action_code: "investigate",
+      assigned_owner: "ops-review"
+    });
+    assert.strictEqual(typeof remediationTicketSummary.ticket_id, "string", "remediation ticket summary missing id");
+    const assignedTicketSummary = await client.actOnRemediationTicketSummary(remediationTicketSummary.ticket_id, {
+      action: "assign",
+      assigned_owner: "ops-review"
+    });
+    assert.strictEqual(assignedTicketSummary.status, "assigned", "remediation action summary missing");
+    const resolvedTicket = await client.actOnRemediationTicket(remediationTicketSummary.ticket_id, {
+      action: "resolve",
+      note: "Handled by ops-review"
+    });
+    assert.strictEqual(resolvedTicket.remediation_ticket.status, "resolved", "remediation resolution missing");
+    const remediationActivity = await client.getRemediationTicketActivitySnapshot(remediationTicketSummary.ticket_id);
+    const remediationActivitySummary = client.summarizeActivitySnapshot(remediationActivity);
+    assert.strictEqual(remediationActivitySummary.remediation_ticket_count >= 1, true, "remediation activity snapshot missing");
+    const remediationActivitySummaryDirect = await client.getRemediationTicketActivitySummary(remediationTicketSummary.ticket_id);
+    assert.strictEqual(remediationActivitySummaryDirect.remediation_ticket_count >= 1, true, "remediation activity summary helper missing");
+    const remediationSummaryDirect = await client.getRemediationTicketSummary(remediationTicketSummary.ticket_id);
+    assert.strictEqual(remediationSummaryDirect.ticket_id, remediationTicketSummary.ticket_id, "remediation summary helper missing");
+    const remediationList = await client.listRemediationTickets({
+      transaction_id: result.transaction.transaction_id,
+      assigned_owner: "ops-review",
+      status: "resolved"
+    });
+    assert.strictEqual(Array.isArray(remediationList.remediation_tickets), true, "remediation ticket list missing");
+    const remediationSummaries = await client.listRemediationTicketSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(remediationSummaries.remediation_ticket_count >= 1, true, "remediation summaries missing");
+    assert.strictEqual(Array.isArray(remediationSummaries.ticket_ids), true, "remediation summary ids missing");
+    const remediationTicketIds = await client.listRemediationTicketIds({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(remediationTicketIds.length >= 1, true, "remediation ticket id list missing");
+    const remediationTicketAssignedOwners = await client.listRemediationTicketAssignedOwners({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(remediationTicketAssignedOwners.length >= 1, true, "remediation assigned owner list missing");
+    const remediationTicketAssignedOwnerSummaries = await client.getRemediationTicketAssignedOwnerSummaries({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(remediationTicketAssignedOwnerSummaries.assigned_owner_count >= 1, true, "remediation assigned owner summaries missing");
+    const filteredRemediationByTitle = await client.listRemediationTickets({ transaction_id: result.transaction.transaction_id, title: "Manual review" });
+    assert.strictEqual(Array.isArray(filteredRemediationByTitle.remediation_tickets), true, "remediation title filter missing");
+    const openIssuesSummary = await client.getOpenIssuesSummary({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(typeof openIssuesSummary.issue_count, "number", "open issues summary missing");
+    assert.strictEqual(Array.isArray(openIssuesSummary.statuses), true, "open issues statuses missing");
+    const executionExceptionsSummary = await client.getExecutionExceptionsSummary({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(typeof executionExceptionsSummary.exception_count, "number", "execution exceptions summary missing");
+    assert.strictEqual(Array.isArray(executionExceptionsSummary.transaction_statuses), true, "execution exception transaction statuses missing");
+    const operationsDashboardSummary = await client.getOperationsDashboardSummary({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(typeof operationsDashboardSummary.attention_count, "number", "operations dashboard summary missing");
+    assert.strictEqual(typeof operationsDashboardSummary.attention_signal_count, "number", "operations dashboard signal count missing");
+    assert.strictEqual(typeof operationsDashboardSummary.open_issues.issue_count, "number", "operations dashboard open issues missing");
+    const attentionRecords = await client.getAttentionRecords({ transaction_id: result.transaction.transaction_id });
+    assert.strictEqual(Array.isArray(attentionRecords.transactions), true, "attention record transactions missing");
+    assert.strictEqual(Array.isArray(attentionRecords.deliveries), true, "attention record deliveries missing");
+    const settledTicket = await client.waitForRemediationTicket(remediationTicketSummary.ticket_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(client.summarizeRemediationTicket(settledTicket).status, "resolved", "remediation summary missing");
+    const settledTicketSummary = await client.waitForRemediationTicketSummary(remediationTicketSummary.ticket_id, {
+      timeoutMs: 1000,
+      pollIntervalMs: 50
+    });
+    assert.strictEqual(settledTicketSummary.status, "resolved", "remediation wait summary missing");
+
+    const instant = await client.execute({
+      command: "quickstart-instant",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-2" }
+    }, {
+      instant: true
+    });
+    assert.strictEqual(typeof instant.transaction.transaction_id, "string", "instant transaction missing");
+    assert.strictEqual(typeof instant.receipt.receipt_id, "string", "instant receipt missing");
+    const instantExecutionSummary = await client.executeInstantSummary({
+      command: "quickstart-instant-summary",
+      task_ref: "trust.verify",
+      body: { subject_id: "subject-2-summary" }
+    });
+    assert.strictEqual(instantExecutionSummary.transaction.transaction_id !== null, true, "instant execution summary missing");
+    const mcpInvocationSummary = await client.invokeMcpToolSummary("zones.lookup", {
+      zone_id: "zone-demo"
+    }, {
+      command: "quickstart-mcp-invoke"
+    });
+    assert.strictEqual(mcpInvocationSummary.transaction.transaction_id !== null, true, "mcp invocation summary missing");
+    const admissionPreviewSummary = await client.previewAdmissionSummary({
+      source_zone_id: "zone-a",
+      target_zone_id: "zone-b"
+    }, {
+      command: "quickstart-admission-preview"
+    });
+    assert.strictEqual(admissionPreviewSummary.transaction.transaction_id !== null, true, "admission preview summary missing");
+    const a2aNegotiation = await client.negotiateA2A({
+      counterparty_agent_id: "agent-counterparty-demo",
+      task_pack_ref: "pack.a2a.demo",
+      negotiation_mode: "quote_then_commit"
+    }, {
+      command: "quickstart-a2a-negotiate"
+    });
+    assert.strictEqual(a2aNegotiation.transaction.transaction_id !== null, true, "a2a negotiation missing");
+    assert.strictEqual(a2aNegotiation.command.deliverables[0].interaction_front, "a2a", "a2a negotiation interaction front missing");
+    const a2aCommit = await client.commitA2A({
+      negotiation_id: "negotiation-demo",
+      intent_id: "intent-a2a-demo"
+    }, {
+      command: "quickstart-a2a-commit"
+    });
+    assert.strictEqual(a2aCommit.transaction.transaction_id !== null, true, "a2a commit missing");
+    assert.strictEqual(typeof a2aCommit.command.deliverables[0].commitment_ref, "string", "a2a commitment ref missing");
+    const a2cSession = await client.openA2CSession({
+      agent_id: "agent-demo",
+      channel_ref: "channel.tools.default"
+    }, {
+      command: "quickstart-a2c-session-open"
+    });
+    assert.strictEqual(a2cSession.transaction.transaction_id !== null, true, "a2c session missing");
+    assert.strictEqual(a2cSession.command.deliverables[0].interaction_front, "a2c", "a2c session interaction front missing");
+    const a2cPackPreview = await client.previewA2CPack({
+      agent_id: "agent-demo",
+      pack_ref: "pack.tools.research"
+    }, {
+      command: "quickstart-a2c-pack-preview"
+    });
+    assert.strictEqual(a2cPackPreview.transaction.transaction_id !== null, true, "a2c pack preview missing");
+    assert.strictEqual(a2cPackPreview.command.deliverables[0].kind, "preview", "a2c pack preview kind missing");
+    const identityAttestationPreview = await client.previewIdentityAttestation({
+      subject_id: "subject-identity-demo",
+      registry_scope: "registry.identity.default"
+    }, {
+      command: "quickstart-identity-attest-preview"
+    });
+    assert.strictEqual(identityAttestationPreview.transaction.transaction_id !== null, true, "identity attestation preview missing");
+    assert.strictEqual(identityAttestationPreview.command.deliverables[0].kind, "preview", "identity attestation preview kind missing");
+    assert.strictEqual(typeof identityAttestationPreview.command.deliverables[0].identity_attestation_ref, "string", "identity attestation preview ref missing");
+    const identityRegistryLink = await client.linkIdentityRegistry({
+      subject_id: "subject-identity-demo",
+      registry_record_id: "registry-record-identity-demo"
+    }, {
+      command: "quickstart-identity-registry-link"
+    });
+    assert.strictEqual(identityRegistryLink.transaction.transaction_id !== null, true, "identity registry link missing");
+    assert.strictEqual(typeof identityRegistryLink.command.deliverables[0].identity_link_ref, "string", "identity registry link ref missing");
+    const registryPackBundle = await client.bundleRegistryPack({
+      pack_ref: "pack.registry.identity",
+      subject_ids: ["subject-identity-demo", "subject-identity-peer"]
+    }, {
+      command: "quickstart-registry-pack-bundle"
+    });
+    assert.strictEqual(registryPackBundle.transaction.transaction_id !== null, true, "registry pack bundle missing");
+    assert.strictEqual(typeof registryPackBundle.command.deliverables[0].registry_pack_ref, "string", "registry pack bundle ref missing");
+    const anchoringPackPreview = await client.previewAnchoringPack({
+      pack_ref: "pack.anchor.identity",
+      commitment_count: 3
+    }, {
+      command: "quickstart-anchoring-pack-preview"
+    });
+    assert.strictEqual(anchoringPackPreview.transaction.transaction_id !== null, true, "anchoring pack preview missing");
+    assert.strictEqual(anchoringPackPreview.command.deliverables[0].kind, "preview", "anchoring pack preview kind missing");
+    assert.strictEqual(typeof anchoringPackPreview.command.deliverables[0].anchor_preview_ref, "string", "anchoring pack preview ref missing");
+    const a2aSettlementFlow = await client.executeA2ASettlementFlow({
+      counterparty_agent_id: "agent-counterparty-demo",
+      task_pack_ref: "pack.a2a.demo",
+      negotiation_mode: "quote_then_commit",
+      negotiation_id: "negotiation-flow-demo",
+      intent_id: "intent-a2a-flow-demo"
+    }, {
+      command: "quickstart-a2a-settlement-flow"
+    });
+    assert.strictEqual(a2aSettlementFlow.transaction.execution.task_count, 3, "a2a settlement flow task count missing");
+    assert.strictEqual(a2aSettlementFlow.command.deliverables.some((entry) => entry.task_ref === "settlement.submit"), true, "a2a settlement flow settlement deliverable missing");
+    const a2cToolingFlow = await client.executeA2CToolingFlow({
+      agent_id: "agent-demo",
+      channel_ref: "channel.tools.default",
+      pack_ref: "pack.tools.research",
+      tool_name: "zones.lookup",
+      arguments: { zone_id: "zone-demo" }
+    }, {
+      command: "quickstart-a2c-tooling-flow"
+    });
+    assert.strictEqual(a2cToolingFlow.transaction.execution.task_count, 3, "a2c tooling flow task count missing");
+    assert.strictEqual(a2cToolingFlow.command.deliverables.some((entry) => entry.task_ref === "adapter.mcp.invoke"), true, "a2c tooling flow mcp deliverable missing");
+    const identityAnchorFlow = await client.executeIdentityAnchorFlow({
+      subject_id: "subject-identity-flow-demo",
+      registry_scope: "registry.identity.default",
+      record_type: "identity_attestation",
+      registry_record_id: "registry-record-identity-flow-demo",
+      commitment_hash: "commitment-identity-flow-demo"
+    }, {
+      command: "quickstart-identity-anchor-flow"
+    });
+    assert.strictEqual(identityAnchorFlow.transaction.execution.task_count, 4, "identity anchor flow task count missing");
+    assert.strictEqual(identityAnchorFlow.command.deliverables.some((entry) => entry.task_ref === "anchoring.submit"), true, "identity anchor flow anchoring deliverable missing");
+    const registryPackAnchorFlow = await client.executeRegistryPackAnchorFlow({
+      pack_ref: "pack.registry.identity",
+      subject_ids: ["subject-identity-flow-demo", "subject-identity-peer"],
+      commitment_count: 2,
+      commitment_hash: "commitment-registry-pack-flow-demo"
+    }, {
+      command: "quickstart-registry-pack-anchor-flow"
+    });
+    assert.strictEqual(registryPackAnchorFlow.transaction.execution.task_count, 3, "registry pack anchor flow task count missing");
+    assert.strictEqual(registryPackAnchorFlow.command.deliverables.some((entry) => entry.task_ref === "registry.pack.bundle"), true, "registry pack anchor flow registry deliverable missing");
+    const trustHandoffSummary = await client.emitTrustHandoffSummary({
+      subject_id: "subject-trust",
+      execution_ref: "exec-trust"
+    }, {
+      command: "quickstart-trust-handoff-emit"
+    });
+    assert.strictEqual(trustHandoffSummary.transaction.transaction_id !== null, true, "trust handoff emit summary missing");
+    const trustHandoffValidationSummary = await client.validateTrustHandoffSummary({
+      handoff_id: "handoff-trust-demo"
+    }, {
+      command: "quickstart-trust-handoff-validate"
+    });
+    assert.strictEqual(trustHandoffValidationSummary.transaction.transaction_id !== null, true, "trust handoff validate summary missing");
+    const executionReceiptHandoffSummary = await client.emitExecutionReceiptHandoffSummary({
+      execution_ref: "exec-receipt-demo"
+    }, {
+      command: "quickstart-execution-receipt-handoff-emit"
+    });
+    assert.strictEqual(executionReceiptHandoffSummary.transaction.transaction_id !== null, true, "execution receipt handoff emit summary missing");
+    const receiptLedgerHandoffSummary = await client.emitReceiptLedgerHandoffSummary({
+      receipt_id: "rcpt-demo",
+      ledger_ref: "ledger-demo"
+    }, {
+      command: "quickstart-receipt-ledger-handoff-emit"
+    });
+    assert.strictEqual(receiptLedgerHandoffSummary.transaction.transaction_id !== null, true, "receipt ledger handoff emit summary missing");
+    const runtimeEmitSummary = await client.emitRuntimeSummary({
+      intent_id: "intent-runtime-emit",
+      event_type: "workflow.started"
+    }, {
+      command: "quickstart-runtime-emit"
+    });
+    assert.strictEqual(runtimeEmitSummary.transaction.transaction_id !== null, true, "runtime emit summary missing");
+    const runtimeAnchorSummary = await client.anchorRuntimeSummary({
+      event_commitment: "commitment-demo"
+    }, {
+      command: "quickstart-runtime-anchor"
+    });
+    assert.strictEqual(runtimeAnchorSummary.transaction.transaction_id !== null, true, "runtime anchor summary missing");
+    const registryRecordSummary = await client.registerRegistryRecordSummary({
+      subject_id: "subject-registry",
+      record_type: "trust"
+    }, {
+      command: "quickstart-registry-register"
+    });
+    assert.strictEqual(registryRecordSummary.transaction.transaction_id !== null, true, "registry register summary missing");
+    const settledInstantExecutionSummary = await client.executeInstantAndWaitSummary({
+      command: "quickstart-instant-summary-wait",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionSummary.delivery_status, "delivered", "instant execution wait summary missing");
+    const settledInstantExecutionActivitySummary = await client.executeInstantAndWaitActivitySummary({
+      command: "quickstart-instant-summary-wait-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionActivitySummary.delivery_count >= 1, true, "instant execution wait activity summary missing");
+    const settledInstantExecutionMonitorSnapshot = await client.executeInstantAndWaitMonitorSnapshot({
+      command: "quickstart-instant-summary-wait-monitor-snapshot",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait-monitor-snapshot" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionMonitorSnapshot.transaction.status, "completed", "instant execution wait monitor snapshot missing");
+    const settledInstantExecutionMonitorSummary = await client.executeInstantAndWaitMonitorSummary({
+      command: "quickstart-instant-summary-wait-monitor",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait-monitor" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionMonitorSummary.status, "completed", "instant execution wait monitor summary missing");
+    const settledInstantExecutionLinkedSummary = await client.executeInstantAndWaitLinkedRecordSummary({
+      command: "quickstart-instant-summary-wait-linked",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait-linked" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionLinkedSummary.delivery_count >= 1, true, "instant execution wait linked summary missing");
+    const settledInstantExecutionLinkedActivitySummary = await client.executeInstantAndWaitLinkedRecordActivitySummary({
+      command: "quickstart-instant-summary-wait-linked-activity",
+      task_ref: "settlement.submit",
+      body: { intent_id: "intent-quickstart-instant-wait-linked-activity" },
+      defer_completion: true
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledInstantExecutionLinkedActivitySummary.transaction_count >= 1, true, "instant execution wait linked activity summary missing");
+
+    const deferred = await client.execute({
+      command: "quickstart-deferred",
+      task_ref: "settlement.submit",
+      defer_completion: true,
+      body: { intent_id: "intent-quickstart" }
+    });
+    assert.strictEqual(deferred.transaction.status, "accepted", "deferred transaction should start accepted");
+    const deferredMonitorRefs = client.extractMonitorRefs(deferred);
+    assert.strictEqual(typeof deferredMonitorRefs.transaction_id, "string", "deferred monitor transaction ref missing");
+    const deferredSnapshot = await client.getMonitorSnapshot(deferred);
+    assert.strictEqual(deferredSnapshot.transaction.status, "accepted", "deferred snapshot transaction missing");
+    assert.strictEqual(deferredSnapshot.receipt.status, "pending", "deferred snapshot receipt missing");
+    const deferredActivity = await client.getMonitorActivitySnapshot(deferred);
+    const deferredActivitySummary = client.summarizeMonitorActivitySnapshot(deferredActivity);
+    assert.strictEqual(deferredActivitySummary.transaction_count >= 1, true, "monitor activity snapshot missing");
+    assert.strictEqual(typeof deferredActivitySummary.refs.transaction_id, "string", "monitor activity refs missing");
+    const deferredActivitySummaryDirect = await client.getMonitorActivitySummary(deferred);
+    assert.strictEqual(deferredActivitySummaryDirect.transaction_count >= 1, true, "monitor activity summary helper missing");
+    const settled = await client.waitForMonitor(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settled.transaction.status, "completed", "deferred transaction did not settle");
+    const settledMonitorSummary = await client.waitForMonitorSummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledMonitorSummary.status, "completed", "deferred monitor wait summary missing");
+    const settledMonitorSnapshot = await client.waitForMonitorSnapshot(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledMonitorSnapshot.transaction.status, "completed", "deferred monitor wait snapshot missing");
+    const settledMonitorActivitySnapshot = await client.waitForMonitorActivitySnapshot(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(client.summarizeActivitySnapshot(settledMonitorActivitySnapshot).transaction_count >= 1, true, "deferred monitor activity wait snapshot missing");
+    const settledMonitorActivitySummary = await client.waitForMonitorActivitySummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledMonitorActivitySummary.transaction_count >= 1, true, "deferred monitor activity wait summary missing");
+    const settledLinkedRecordSet = await client.waitForLinkedRecordSet(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledLinkedRecordSet.transaction.status, "completed", "deferred linked record wait set missing");
+    const settledLinkedRecordActivitySnapshot = await client.waitForLinkedRecordActivitySnapshot(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(client.summarizeActivitySnapshot(settledLinkedRecordActivitySnapshot).transaction_count >= 1, true, "deferred linked record activity wait snapshot missing");
+    const settledLinkedRecordSummary = await client.waitForLinkedRecordSummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledLinkedRecordSummary.delivery_count >= 1, true, "deferred linked record wait summary missing");
+    const settledLinkedRecordActivitySummary = await client.waitForLinkedRecordActivitySummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledLinkedRecordActivitySummary.transaction_count >= 1, true, "deferred linked record activity wait summary missing");
+    const settledQuote = await client.waitForQuote(deferred.transaction.quote_id, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledQuote.quote.status, "executed", "deferred quote did not settle");
+    const settledQuoteSummary = await client.waitForQuoteSummary(deferred.transaction.quote_id, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledQuoteSummary.status, "executed", "deferred quote wait summary missing");
+    const settledTransactionSummary = await client.waitForTransactionSummary(deferred.transaction.transaction_id, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTransactionSummary.status, "completed", "deferred transaction wait summary missing");
+    const settledResultSet = await client.waitForResultSet(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledResultSet.transaction.status, "completed", "result-set transaction missing");
+    assert.strictEqual(settledResultSet.receipt.status, "completed", "result-set receipt missing");
+    assert.strictEqual(settledResultSet.delivery.status, "delivered", "result-set delivery missing");
+    const settledDeliverySummary = await client.waitForDeliverySummary(settledResultSet.delivery.delivery_id, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledDeliverySummary.status, "delivered", "deferred delivery wait summary missing");
+    const settledResultSummary = client.summarizeResultSet(settledResultSet);
+    assert.strictEqual(settledResultSummary.transaction_status, "completed", "result-set summary transaction missing");
+    assert.strictEqual(settledResultSummary.delivery_status, "delivered", "result-set summary delivery missing");
+    const settledWorkflowSummary = await client.executeWorkflowAndWaitSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-d" },
+      "settlement.submit": { intent_id: "intent-4" }
+    }, {
+      command: "quickstart-workflow-run-wait-summary",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowSummary.delivery_status, "delivered", "workflow settled summary missing");
+    const settledWorkflowSummaries = await client.executeWorkflowAndWaitSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch" },
+          "settlement.submit": { intent_id: "intent-4-batch" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-summary-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowSummaries.workflow_count, 2, "workflow settled summaries missing");
+    const settledWorkflowActivitySummaries = await client.executeWorkflowAndWaitActivitySummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-activity" },
+          "settlement.submit": { intent_id: "intent-4-batch-activity" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-activity" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-activity" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-activity-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowActivitySummaries.workflow_count, 2, "workflow settled activity summaries missing");
+    const settledWorkflowActivitySnapshots = await client.executeWorkflowAndWaitActivitySnapshots([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-activity-snapshot" },
+          "settlement.submit": { intent_id: "intent-4-batch-activity-snapshot" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-activity-snapshot" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-activity-snapshot" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-activity-snapshot-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowActivitySnapshots.workflow_count, 2, "workflow settled activity snapshots missing");
+    const settledWorkflowMonitorSummaries = await client.executeWorkflowAndWaitMonitorSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-monitor" },
+          "settlement.submit": { intent_id: "intent-4-batch-monitor" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-monitor" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-monitor" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-monitor-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowMonitorSummaries.workflow_count, 2, "workflow settled monitor summaries missing");
+    const settledWorkflowMonitorSnapshots = await client.executeWorkflowAndWaitMonitorSnapshots([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-monitor-snapshot" },
+          "settlement.submit": { intent_id: "intent-4-batch-monitor-snapshot" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-monitor-snapshot" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-monitor-snapshot" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-monitor-snapshot-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowMonitorSnapshots.workflow_count, 2, "workflow settled monitor snapshots missing");
+    const settledWorkflowMonitorActivitySnapshots = await client.executeWorkflowAndWaitMonitorActivitySnapshots([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-monitor-activity-snapshot" },
+          "settlement.submit": { intent_id: "intent-4-batch-monitor-activity-snapshot" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-monitor-activity-snapshot" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-monitor-activity-snapshot" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-monitor-activity-snapshot-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowMonitorActivitySnapshots.workflow_count, 2, "workflow settled monitor activity snapshots missing");
+    const settledWorkflowMonitorActivitySummaries = await client.executeWorkflowAndWaitMonitorActivitySummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-monitor-activity-summary" },
+          "settlement.submit": { intent_id: "intent-4-batch-monitor-activity-summary" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-monitor-activity-summary" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-monitor-activity-summary" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-monitor-activity-summary-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowMonitorActivitySummaries.workflow_count, 2, "workflow settled monitor activity summaries missing");
+    const settledWorkflowLinkedSummaries = await client.executeWorkflowAndWaitLinkedRecordSummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-linked" },
+          "settlement.submit": { intent_id: "intent-4-batch-linked" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-linked" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-linked" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-linked-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedSummaries.workflow_count, 2, "workflow settled linked summaries missing");
+    const settledWorkflowLinkedSets = await client.executeWorkflowAndWaitLinkedRecordSets([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-linked-set" },
+          "settlement.submit": { intent_id: "intent-4-batch-linked-set" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-linked-set" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-linked-set" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-linked-set-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedSets.workflow_count, 2, "workflow settled linked sets missing");
+    const settledWorkflowLinkedActivitySummaries = await client.executeWorkflowAndWaitLinkedRecordActivitySummaries([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-linked-activity" },
+          "settlement.submit": { intent_id: "intent-4-batch-linked-activity" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-linked-activity" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-linked-activity" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-linked-activity-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedActivitySummaries.workflow_count, 2, "workflow settled linked activity summaries missing");
+    const settledWorkflowLinkedActivitySnapshots = await client.executeWorkflowAndWaitLinkedRecordActivitySnapshots([
+      {
+        workflow_ref: "policy.transaction.flow",
+        task_bodies_by_ref: {
+          "policy.simulate": { policy: "policy-d-batch-linked-activity-snapshot" },
+          "settlement.submit": { intent_id: "intent-4-batch-linked-activity-snapshot" }
+        }
+      },
+      {
+        workflow_ref: "trust.flow",
+        task_bodies_by_ref: {
+          "trust.verify": { subject_id: "subject-4-batch-linked-activity-snapshot" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch-linked-activity-snapshot" }
+        }
+      }
+    ], {
+      command: "quickstart-workflow-run-wait-linked-activity-snapshot-batch",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedActivitySnapshots.workflow_count, 2, "workflow settled linked activity snapshots missing");
+    const settledResultSummaryDirect = await client.getResultSetSummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledResultSummaryDirect.transaction_status, "completed", "result-set summary helper missing");
+    const settledResultActivitySnapshot = await client.waitForResultSetActivitySnapshot(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(client.summarizeActivitySnapshot(settledResultActivitySnapshot).transaction_count >= 1, true, "result-set activity snapshot missing");
+    const settledResultActivitySummary = await client.waitForResultSetActivitySummary(deferred, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledResultActivitySummary.transaction_count >= 1, true, "result-set activity summary missing");
+    const linkedDeferredSet = await client.getLinkedRecordSet(deferred);
+    assert.strictEqual(linkedDeferredSet.transaction.status, "completed", "linked deferred transaction missing");
+    assert.strictEqual(linkedDeferredSet.payment_ledger.length >= 1, true, "linked deferred payment ledger missing");
+
+    const taskSetPayload = await client.buildWorkflowTaskSet("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-a" },
+      "settlement.submit": { intent_id: "intent-1" }
+    }, {
+      command: "quickstart-task-set"
+    });
+    const taskSetResult = await client.execute(taskSetPayload);
+    assert.strictEqual(taskSetResult.transaction.execution.task_count, 2, "task-set execution count missing");
+    assert.strictEqual(taskSetResult.receipt.execution_summary.task_count, 2, "task-set receipt count missing");
+    const taskSetSummary = await client.executeTaskSetSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-summary" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-summary" } }
+    ], {
+      command: "quickstart-task-set-summary"
+    });
+    assert.strictEqual(taskSetSummary.transaction.task_count, 2, "task-set summary missing");
+    const taskSetSummaries = await client.executeTaskSetSummaries([
+      {
+        task_set_id: "task-set-summary-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-summary-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-summary-batch-a" } }
+        ],
+        options: { command: "quickstart-task-set-summary-batch-a" }
+      },
+      {
+        task_set_id: "task-set-summary-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-summary-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-summary-batch-b" } }
+        ],
+        options: { command: "quickstart-task-set-summary-batch-b" }
+      }
+    ]);
+    assert.strictEqual(taskSetSummaries.task_set_count, 2, "task-set summaries batch missing");
+    const settledTaskSetSummary = await client.executeTaskSetAndWaitSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-summary" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-summary" } }
+    ], {
+      command: "quickstart-task-set-wait-summary",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTaskSetSummary.delivery_status, "delivered", "task-set settled summary missing");
+    const settledTaskSetSummaries = await client.executeTaskSetAndWaitSummaries([
+      {
+        task_set_id: "task-set-wait-summary-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-summary-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-summary-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-summary-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-summary-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-summary-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-summary-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-summary-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetSummaries.task_set_count, 2, "task-set settled summaries batch missing");
+    const settledTaskSetActivitySummaries = await client.executeTaskSetAndWaitActivitySummaries([
+      {
+        task_set_id: "task-set-wait-activity-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-activity-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-activity-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-activity-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-activity-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-activity-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-activity-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-activity-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetActivitySummaries.task_set_count, 2, "task-set settled activity summaries batch missing");
+    const settledTaskSetActivitySnapshots = await client.executeTaskSetAndWaitActivitySnapshots([
+      {
+        task_set_id: "task-set-wait-activity-snapshot-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-activity-snapshot-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-activity-snapshot-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-activity-snapshot-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-activity-snapshot-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-activity-snapshot-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-activity-snapshot-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-activity-snapshot-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetActivitySnapshots.task_set_count, 2, "task-set settled activity snapshots batch missing");
+    const settledTaskSetMonitorSummaries = await client.executeTaskSetAndWaitMonitorSummaries([
+      {
+        task_set_id: "task-set-wait-monitor-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-monitor-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-monitor-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-monitor-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-monitor-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-monitor-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetMonitorSummaries.task_set_count, 2, "task-set settled monitor summaries batch missing");
+    const settledTaskSetMonitorSnapshots = await client.executeTaskSetAndWaitMonitorSnapshots([
+      {
+        task_set_id: "task-set-wait-monitor-snapshot-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-monitor-snapshot-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-monitor-snapshot-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-snapshot-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-monitor-snapshot-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-monitor-snapshot-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-monitor-snapshot-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-snapshot-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetMonitorSnapshots.task_set_count, 2, "task-set settled monitor snapshots batch missing");
+    const settledTaskSetMonitorActivitySnapshots = await client.executeTaskSetAndWaitMonitorActivitySnapshots([
+      {
+        task_set_id: "task-set-wait-monitor-activity-snapshot-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-monitor-activity-snapshot-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-monitor-activity-snapshot-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-activity-snapshot-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-monitor-activity-snapshot-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-monitor-activity-snapshot-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-monitor-activity-snapshot-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-activity-snapshot-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetMonitorActivitySnapshots.task_set_count, 2, "task-set settled monitor activity snapshots batch missing");
+    const settledTaskSetMonitorActivitySummaries = await client.executeTaskSetAndWaitMonitorActivitySummaries([
+      {
+        task_set_id: "task-set-wait-monitor-activity-summary-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-monitor-activity-summary-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-monitor-activity-summary-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-activity-summary-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-monitor-activity-summary-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-monitor-activity-summary-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-monitor-activity-summary-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-monitor-activity-summary-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetMonitorActivitySummaries.task_set_count, 2, "task-set settled monitor activity summaries batch missing");
+    const settledTaskSetLinkedSummaries = await client.executeTaskSetAndWaitLinkedRecordSummaries([
+      {
+        task_set_id: "task-set-wait-linked-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-linked-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-linked-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-linked-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetLinkedSummaries.task_set_count, 2, "task-set settled linked summaries batch missing");
+    const settledTaskSetLinkedSets = await client.executeTaskSetAndWaitLinkedRecordSets([
+      {
+        task_set_id: "task-set-wait-linked-set-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked-set-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked-set-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-set-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-linked-set-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-linked-set-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-linked-set-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-set-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetLinkedSets.task_set_count, 2, "task-set settled linked sets batch missing");
+    const settledTaskSetLinkedActivitySummaries = await client.executeTaskSetAndWaitLinkedRecordActivitySummaries([
+      {
+        task_set_id: "task-set-wait-linked-activity-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked-activity-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked-activity-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-activity-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-linked-activity-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-linked-activity-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-linked-activity-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-activity-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetLinkedActivitySummaries.task_set_count, 2, "task-set settled linked activity summaries batch missing");
+    const settledTaskSetLinkedActivitySnapshots = await client.executeTaskSetAndWaitLinkedRecordActivitySnapshots([
+      {
+        task_set_id: "task-set-wait-linked-activity-snapshot-a",
+        tasks: [
+          { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked-activity-snapshot-batch-a" } },
+          { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked-activity-snapshot-batch-a" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-activity-snapshot-batch-a",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      },
+      {
+        task_set_id: "task-set-wait-linked-activity-snapshot-b",
+        tasks: [
+          { task_ref: "trust.verify", body: { subject_id: "subject-task-set-wait-linked-activity-snapshot-batch-b" } },
+          { task_ref: "receipt.validate", body: { receipt_id: "rcpt-task-set-wait-linked-activity-snapshot-batch-b" } }
+        ],
+        options: {
+          command: "quickstart-task-set-wait-linked-activity-snapshot-batch-b",
+          defer_completion: true,
+          timeoutMs: 5000,
+          pollIntervalMs: 100
+        }
+      }
+    ]);
+    assert.strictEqual(settledTaskSetLinkedActivitySnapshots.task_set_count, 2, "task-set settled linked activity snapshots batch missing");
+    const settledTaskSetActivitySummary = await client.executeTaskSetAndWaitActivitySummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-activity" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-activity" } }
+    ], {
+      command: "quickstart-task-set-wait-activity",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTaskSetActivitySummary.delivery_count >= 1, true, "task-set settled activity summary missing");
+    const settledTaskSetMonitorSummary = await client.executeTaskSetAndWaitMonitorSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-monitor" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-monitor" } }
+    ], {
+      command: "quickstart-task-set-wait-monitor",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTaskSetMonitorSummary.status, "completed", "task-set settled monitor summary missing");
+    const settledTaskSetLinkedSummary = await client.executeTaskSetAndWaitLinkedRecordSummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked" } }
+    ], {
+      command: "quickstart-task-set-wait-linked",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTaskSetLinkedSummary.delivery_count >= 1, true, "task-set settled linked summary missing");
+    const settledTaskSetLinkedActivitySummary = await client.executeTaskSetAndWaitLinkedRecordActivitySummary([
+      { task_ref: "policy.simulate", body: { policy: "policy-task-set-wait-linked-activity" } },
+      { task_ref: "settlement.submit", body: { intent_id: "intent-task-set-wait-linked-activity" } }
+    ], {
+      command: "quickstart-task-set-wait-linked-activity",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledTaskSetLinkedActivitySummary.transaction_count >= 1, true, "task-set settled linked activity summary missing");
+    const workflowResult = await client.executeWorkflow("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-b" },
+      "settlement.submit": { intent_id: "intent-2" }
+    }, {
+      command: "quickstart-workflow-run"
+    });
+    assert.strictEqual(workflowResult.transaction.execution.task_count, 2, "workflow execution count missing");
+    const settledWorkflowResult = await client.executeWorkflowAndWait("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-c" },
+      "settlement.submit": { intent_id: "intent-3" }
+    }, {
+      command: "quickstart-workflow-run-wait",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowResult.transaction.status, "completed", "workflow settled transaction missing");
+    assert.strictEqual(settledWorkflowResult.delivery.status, "delivered", "workflow settled delivery missing");
+    const settledWorkflowActivitySummary = await client.executeWorkflowAndWaitActivitySummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-c-activity" },
+      "settlement.submit": { intent_id: "intent-3-activity" }
+    }, {
+      command: "quickstart-workflow-run-wait-activity",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowActivitySummary.delivery_count >= 1, true, "workflow settled activity summary missing");
+    const settledWorkflowMonitorSummary = await client.executeWorkflowAndWaitMonitorSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-c-monitor" },
+      "settlement.submit": { intent_id: "intent-3-monitor" }
+    }, {
+      command: "quickstart-workflow-run-wait-monitor",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowMonitorSummary.status, "completed", "workflow settled monitor summary missing");
+    const settledWorkflowLinkedSummary = await client.executeWorkflowAndWaitLinkedRecordSummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-c-linked" },
+      "settlement.submit": { intent_id: "intent-3-linked" }
+    }, {
+      command: "quickstart-workflow-run-wait-linked",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedSummary.delivery_count >= 1, true, "workflow settled linked summary missing");
+    const settledWorkflowLinkedActivitySummary = await client.executeWorkflowAndWaitLinkedRecordActivitySummary("policy.transaction.flow", {
+      "policy.simulate": { policy: "policy-c-linked-activity" },
+      "settlement.submit": { intent_id: "intent-3-linked-activity" }
+    }, {
+      command: "quickstart-workflow-run-wait-linked-activity",
+      defer_completion: true,
+      timeoutMs: 5000,
+      pollIntervalMs: 100
+    });
+    assert.strictEqual(settledWorkflowLinkedActivitySummary.transaction_count >= 1, true, "workflow settled linked activity summary missing");
+    const quoteList = await client.listPaymentQuotes({ status: "executed", account_id: "acct_demo" });
+    assert.strictEqual(Array.isArray(quoteList.quotes), true, "quote list missing");
+    const activitySnapshot = await client.getActivitySnapshot({ account_id: "acct_demo" });
+    const activitySummary = client.summarizeActivitySnapshot(activitySnapshot);
+    assert.strictEqual(activitySummary.transaction_count >= 1, true, "activity snapshot missing");
+    const activitySummaryDirect = await client.getActivitySummary({ account_id: "acct_demo" });
+    assert.strictEqual(activitySummaryDirect.transaction_count >= 1, true, "activity summary helper missing");
+    const quoteActivity = await client.getQuoteActivitySnapshot(result.transaction.quote_id);
+    const quoteActivitySummary = client.summarizeActivitySnapshot(quoteActivity);
+    assert.strictEqual(quoteActivitySummary.quote_count >= 1, true, "quote activity snapshot missing");
+    const quoteActivitySummaryDirect = await client.getQuoteActivitySummary(result.transaction.quote_id);
+    assert.strictEqual(quoteActivitySummaryDirect.quote_count >= 1, true, "quote activity summary helper missing");
+    const transactionActivity = await client.getTransactionActivitySnapshot(result.transaction.transaction_id);
+    const transactionActivitySummary = client.summarizeActivitySnapshot(transactionActivity);
+    assert.strictEqual(transactionActivitySummary.transaction_count >= 1, true, "transaction activity snapshot missing");
+    const transactionActivitySummaryDirect = await client.getTransactionActivitySummary(result.transaction.transaction_id);
+    assert.strictEqual(transactionActivitySummaryDirect.transaction_count >= 1, true, "transaction activity summary helper missing");
+    const receiptActivity = await client.getReceiptActivitySnapshot(result.receipt.receipt_id);
+    const receiptActivitySummary = client.summarizeActivitySnapshot(receiptActivity);
+    assert.strictEqual(receiptActivitySummary.receipt_count >= 1, true, "receipt activity snapshot missing");
+    const receiptActivitySummaryDirect = await client.getReceiptActivitySummary(result.receipt.receipt_id);
+    assert.strictEqual(receiptActivitySummaryDirect.receipt_count >= 1, true, "receipt activity summary helper missing");
+    const paymentActivity = await client.getPaymentActivitySnapshot(paymentEntry.payment.payment_id);
+    const paymentActivitySummary = client.summarizeActivitySnapshot(paymentActivity);
+    assert.strictEqual(paymentActivitySummary.payment_ledger_count >= 1, true, "payment activity snapshot missing");
+    const paymentActivitySummaryDirect = await client.getPaymentActivitySummary(paymentEntry.payment.payment_id);
+    assert.strictEqual(paymentActivitySummaryDirect.payment_ledger_count >= 1, true, "payment activity summary helper missing");
+    const deliveryActivity = await client.getDeliveryActivitySnapshot(delivery.delivery.delivery_id);
+    const deliveryActivitySummary = client.summarizeActivitySnapshot(deliveryActivity);
+    assert.strictEqual(deliveryActivitySummary.delivery_count >= 1, true, "delivery activity snapshot missing");
+    const deliveryActivitySummaryDirect = await client.getDeliveryActivitySummary(delivery.delivery.delivery_id);
+    assert.strictEqual(deliveryActivitySummaryDirect.delivery_count >= 1, true, "delivery activity summary helper missing");
+    const reconciliation = await client.getReconciliationReport();
+    assert.strictEqual(typeof reconciliation.summary, "object", "reconciliation report missing");
+    const reconciliationSummary = client.summarizeReconciliationReport(reconciliation);
+    assert.strictEqual(typeof reconciliationSummary.delivery_count, "number", "reconciliation summary missing");
+    const reconciliationSummaryDirect = await client.getReconciliationReportSummary();
+    assert.strictEqual(typeof reconciliationSummaryDirect.delivery_count, "number", "reconciliation summary helper missing");
+    const exportPack = await client.getOperatorExportPack();
+    assert.strictEqual(typeof exportPack.aggregates, "object", "operator export pack missing");
+    const exportSummary = client.summarizeOperatorExportPack(exportPack);
+    assert.strictEqual(typeof exportSummary.payment_ledger_count, "number", "operator export summary missing");
+    const exportSummaryDirect = await client.getOperatorExportPackSummary();
+    assert.strictEqual(typeof exportSummaryDirect.payment_ledger_count, "number", "operator export summary helper missing");
+
+    console.log("xytara quickstart passed");
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
+