xytara 3.0.1 → 3.1.1

package/examples/quickstart.js

@@ -1,42 +1,43 @@
 "use strict";
 
 const assert = require("assert");
+const demoEnv = require("./_demo_env");
 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");
-
+
+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");
@@ -1051,9 +1052,9 @@ async function main() {
     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 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");
@@ -1064,10 +1065,10 @@ async function main() {
     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 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);
@@ -1138,12 +1139,12 @@ async function main() {
     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 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");
@@ -1154,24 +1155,24 @@ async function main() {
     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 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([
+    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: [
@@ -1193,13 +1194,13 @@ async function main() {
         }
       }
     ], { 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([
+    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: {
@@ -1221,30 +1222,30 @@ async function main() {
         }
       }
     ], { 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([
+    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: [
@@ -1266,27 +1267,27 @@ async function main() {
         }
       }
     ], { 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");
+    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",
@@ -1336,40 +1337,40 @@ async function main() {
     ]);
     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 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"
-        }
+          { 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");
@@ -1391,20 +1392,20 @@ async function main() {
     ]);
     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 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",
@@ -1454,40 +1455,40 @@ async function main() {
     ]);
     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 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"
-        }
+          { 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");
@@ -1509,14 +1510,14 @@ async function main() {
     ]);
     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([
+    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: {
@@ -1539,9 +1540,9 @@ async function main() {
       }
     ], {
       command: "quickstart-workflow-summary-batch"
-    });
-    assert.strictEqual(workflowExecutionSummaries.workflow_count, 2, "workflow execution summaries missing");
-
+    });
+    assert.strictEqual(workflowExecutionSummaries.workflow_count, 2, "workflow execution summaries missing");
+
     const quote = await client.createExecutionQuote({
       command: "quickstart",
       task_ref: "trust.verify",
@@ -1553,56 +1554,56 @@ async function main() {
     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 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
+    }, {
+      timeoutMs: 5000,
+      pollIntervalMs: 100
     });
     assert.strictEqual(settledExecutionActivitySummary.delivery_count >= 1, true, "execution wait activity summary missing");
     const settledExecutionMonitorSnapshot = await client.executeAndWaitMonitorSnapshot({
@@ -1619,50 +1620,50 @@ async function main() {
       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
+      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({
@@ -1679,49 +1680,49 @@ async function main() {
       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");
-
+      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",
@@ -1743,7 +1744,7 @@ async function main() {
       grant_id: "quickstart_credit_grant_1",
       account_id: "acct_demo",
       pack_id: "credits.agent"
-    });
+    }, { bearerToken: demoEnv.demoCreditBridgeToken });
     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");
@@ -1795,7 +1796,7 @@ async function main() {
     const spendCredential = await client.createSpendCredential({
       credential_id: "quickstart_spend_credential_1",
       account_id: "acct_demo"
-    });
+    }, { bearerToken: demoEnv.demoAccountAuthToken });
     assert.strictEqual(spendCredential.credential_id, "quickstart_spend_credential_1", "spend credential create missing");
     const delegatedCreditResult = await client.executeWithSpendCredential({
       payment_preference: "credits_first",
@@ -1809,7 +1810,7 @@ async function main() {
       credential_id: "quickstart_spend_credential_pool_1",
       account_id: "acct_demo",
       entitlement_id: creditGrant.entitlement.entitlement_id
-    });
+    }, { bearerToken: demoEnv.demoAccountAuthToken });
     assert.strictEqual(poolBoundSpendCredential.effective_pool_binding_mode, "entitlement_bound", "pool-bound spend credential mode missing");
     const poolBoundDelegatedResult = await client.executeWithSpendCredential({
       payment_preference: "credits_first",
@@ -1836,7 +1837,7 @@ async function main() {
       account_id: "acct_demo",
       pack_id: "credits.topup",
       purchase_reference: "purchase-export-topup-1"
-    });
+    }, { bearerToken: demoEnv.demoCreditBridgeToken });
     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",
@@ -1862,18 +1863,18 @@ async function main() {
     );
     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");
+    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");
@@ -1932,8 +1933,8 @@ async function main() {
     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 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 });
@@ -1943,13 +1944,13 @@ async function main() {
     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 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 });
@@ -1961,31 +1962,31 @@ async function main() {
     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 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 });
@@ -1997,16 +1998,16 @@ async function main() {
     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 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,
@@ -2022,19 +2023,19 @@ async function main() {
       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");
+    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 });
@@ -2048,45 +2049,45 @@ async function main() {
     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"
+    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 });
@@ -2117,22 +2118,22 @@ async function main() {
       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");
+    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",
@@ -2312,20 +2313,20 @@ async function main() {
       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
+      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({
@@ -2342,625 +2343,625 @@ async function main() {
       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(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(settledWorkflowMonitorActivitySnapshots.workflow_count, 2, "workflow settled monitor activity snapshots missing");
-    const settledWorkflowMonitorActivitySummaries = await client.executeWorkflowAndWaitMonitorActivitySummaries([
+    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-monitor-activity-summary" },
-          "settlement.submit": { intent_id: "intent-4-batch-monitor-activity-summary" }
+          "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-monitor-activity-summary" },
-          "receipt.validate": { receipt_id: "rcpt-4-batch-monitor-activity-summary" }
+          "trust.verify": { subject_id: "subject-4-batch" },
+          "receipt.validate": { receipt_id: "rcpt-4-batch" }
         }
       }
     ], {
-      command: "quickstart-workflow-run-wait-monitor-activity-summary-batch",
+      command: "quickstart-workflow-run-wait-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([
+    assert.strictEqual(settledWorkflowSummaries.workflow_count, 2, "workflow settled summaries missing");
+    const settledWorkflowActivitySummaries = await client.executeWorkflowAndWaitActivitySummaries([
       {
-        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",
+        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
@@ -2982,274 +2983,274 @@ async function main() {
     ]);
     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;
-});
-
+      {
+        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;
+});
+