xytara 1.7.0 → 1.8.0

package/README.md

@@ -105,6 +105,22 @@ The current `1.7.0` line starts widening that surface into real grouped transact
 
 This is the first step beyond “clear default loop” toward “broader useful machine-commerce classes plus clearer commerce-to-proof follow-through.”
 
+The current `1.8.0` line starts filling a thinner part of the interaction spine before committed execution:
+
+- grouped pre-commit pack catalog, summary, and detail routes
+- grouped pre-commit run routes for negotiation, admission, and commit-readiness posture
+- readiness summaries that make the next committed transaction surface more explicit
+
+This is intended to make the protocol-entry to committed-transaction transition feel more like one composable machine spine instead of a set of disconnected route families.
+
+The same `1.8.0` line also starts exposing grouped interaction spine paths that compose:
+
+- pre-commit readiness
+- committed execution
+- proof-aware handoff posture
+
+as one clearer cross-layer machine path instead of making callers stitch the layers together manually.
+
 ## Package Surface
 
 The SDK is broad, but it stays organized into a few repeatable families instead of one-off surfaces.

package/index.js

@@ -40,7 +40,7 @@ const {
 } = require("./integrations/registry");
 
 const COMMERCE_SDK_NAME = "xytara";
-const COMMERCE_SDK_VERSION = "1.7.0";
+const COMMERCE_SDK_VERSION = "1.8.0";
 const COMMERCE_API_VERSION = "v1";
 
 function createClient(options) {

package/lib/catalog_contract.js

@@ -187,6 +187,123 @@ function buildTransactionClassPacks() {
   ];
 }
 
+function buildPrecommitInteractionPacks() {
+  const center = buildDefaultTransactionCenter();
+  const defaultSettlementMode = center.default_settlement && center.default_settlement.settlement_mode
+    ? center.default_settlement.settlement_mode
+    : null;
+  const defaultPaymentProtocol = center.default_payment && center.default_payment.protocol
+    ? center.default_payment.protocol
+    : null;
+  return [
+    {
+      precommit_pack_ref: "precommit.a2a.settlement.readiness",
+      title: "A2A Settlement Readiness",
+      description: "Negotiate, preview admission, and confirm commit posture before a committed settlement-class transaction.",
+      category: "a2a",
+      protocol: "a2a",
+      task_refs: ["a2a.negotiate", "admission.preview", "a2a.commit"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      commitment_signal: "a2a.commit",
+      readiness_kind: "settlement_commit_readiness",
+      recommended_next_surface: "/v1/transaction-center/transaction-class-packs/run",
+      recommended_next_ref: "transaction.admission.settlement",
+      required_inputs: ["counterparty_agent_id", "intent_id", "source_zone_id", "target_zone_id"],
+      optional_inputs: ["task_pack_ref", "negotiation_mode", "interaction_class", "payment_protocol", "settlement_mode"]
+    },
+    {
+      precommit_pack_ref: "precommit.a2c.tooling.readiness",
+      title: "A2C Tooling Readiness",
+      description: "Open the session, preview the tooling pack, and confirm admission posture before committed tooling execution.",
+      category: "a2c",
+      protocol: "a2c",
+      task_refs: ["a2c.session.open", "a2c.pack.preview", "admission.preview"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      commitment_signal: "a2c.pack.preview",
+      readiness_kind: "tooling_commit_readiness",
+      recommended_next_surface: "/v1/transaction-center/task-packs/invoke",
+      recommended_next_ref: "default.a2c.tooling.run",
+      required_inputs: ["agent_id", "channel_ref", "pack_ref", "source_zone_id", "target_zone_id"],
+      optional_inputs: ["interaction_class", "payment_protocol", "settlement_mode"]
+    },
+    {
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      title: "Job Commitment Readiness",
+      description: "Quote, preview admission, and reserve the job before committing the full job transaction class.",
+      category: "jobs",
+      protocol: "job",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      commitment_signal: "jobs.reserve",
+      readiness_kind: "job_commitment_readiness",
+      recommended_next_surface: "/v1/transaction-center/transaction-class-packs/run",
+      recommended_next_ref: "transaction.job.commitment",
+      required_inputs: ["job_type", "job_id", "source_zone_id", "target_zone_id", "intent_id"],
+      optional_inputs: ["interaction_class", "payment_protocol", "settlement_mode"]
+    }
+  ];
+}
+
+function buildInteractionSpinePaths() {
+  const center = buildDefaultTransactionCenter();
+  const defaultSettlementMode = center.default_settlement && center.default_settlement.settlement_mode
+    ? center.default_settlement.settlement_mode
+    : null;
+  const defaultPaymentProtocol = center.default_payment && center.default_payment.protocol
+    ? center.default_payment.protocol
+    : null;
+  return [
+    {
+      spine_path_ref: "spine.a2a.settlement",
+      title: "A2A Settlement Spine",
+      description: "Compose negotiation, admission, commit, and settlement as one grouped machine-interaction spine path.",
+      category: "a2a",
+      protocol: "a2a",
+      precommit_pack_ref: "precommit.a2a.settlement.readiness",
+      committed_ref: "transaction.admission.settlement",
+      task_refs: ["a2a.negotiate", "admission.preview", "a2a.commit", "settlement.submit"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      proof_followthrough: "default.proof.bundle.loop",
+      required_inputs: ["counterparty_agent_id", "intent_id", "source_zone_id", "target_zone_id"],
+      optional_inputs: ["task_pack_ref", "negotiation_mode", "interaction_class", "payment_protocol", "settlement_mode"]
+    },
+    {
+      spine_path_ref: "spine.a2c.tooling",
+      title: "A2C Tooling Spine",
+      description: "Compose session open, pack preview, admission posture, and committed tooling execution as one grouped path.",
+      category: "a2c",
+      protocol: "a2c",
+      precommit_pack_ref: "precommit.a2c.tooling.readiness",
+      committed_ref: "default.a2c.tooling.run",
+      task_refs: ["a2c.session.open", "a2c.pack.preview", "admission.preview", "adapter.mcp.invoke"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      proof_followthrough: "default.proof.bundle.loop",
+      required_inputs: ["agent_id", "channel_ref", "pack_ref", "tool_name", "source_zone_id", "target_zone_id"],
+      optional_inputs: ["arguments", "interaction_class", "payment_protocol", "settlement_mode"]
+    },
+    {
+      spine_path_ref: "spine.job.commitment",
+      title: "Job Commitment Spine",
+      description: "Compose quote, admission, reserve, and commit as one grouped job interaction spine path.",
+      category: "jobs",
+      protocol: "job",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      committed_ref: "transaction.job.commitment",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      default_payment_protocol: defaultPaymentProtocol,
+      default_settlement_mode: defaultSettlementMode,
+      proof_followthrough: "default.proof.bundle.loop",
+      required_inputs: ["job_type", "job_id", "source_zone_id", "target_zone_id"],
+      optional_inputs: ["intent_id", "interaction_class", "payment_protocol", "settlement_mode"]
+    }
+  ];
+}
+
 function buildDefaultTransactionCenter() {
   const settlementProfiles = Array.isArray(catalog.settlement_profiles) ? catalog.settlement_profiles : [];
   const defaultSettlementProfile = settlementProfiles[0] || null;
@@ -403,6 +520,34 @@ function buildTransactionClassPackCatalog() {
   };
 }
 
+function buildPrecommitInteractionPackCatalog() {
+  const center = buildDefaultTransactionCenter();
+  const packs = buildPrecommitInteractionPacks();
+  return {
+    ok: true,
+    brand: center.brand,
+    product: "precommit interaction packs",
+    default_payment_protocol: center.default_payment && center.default_payment.protocol ? center.default_payment.protocol : null,
+    default_settlement_mode: center.default_settlement && center.default_settlement.settlement_mode ? center.default_settlement.settlement_mode : null,
+    precommit_pack_count: packs.length,
+    precommit_packs: packs
+  };
+}
+
+function buildInteractionSpinePathCatalog() {
+  const center = buildDefaultTransactionCenter();
+  const paths = buildInteractionSpinePaths();
+  return {
+    ok: true,
+    brand: center.brand,
+    product: "interaction spine paths",
+    default_payment_protocol: center.default_payment && center.default_payment.protocol ? center.default_payment.protocol : null,
+    default_settlement_mode: center.default_settlement && center.default_settlement.settlement_mode ? center.default_settlement.settlement_mode : null,
+    spine_path_count: paths.length,
+    spine_paths: paths
+  };
+}
+
 function summarizeTransactionClassPacks() {
   const catalogResponse = buildTransactionClassPackCatalog();
   const packs = Array.isArray(catalogResponse.class_packs) ? catalogResponse.class_packs : [];
@@ -419,12 +564,56 @@ function summarizeTransactionClassPacks() {
   };
 }
 
+function summarizePrecommitInteractionPacks() {
+  const catalogResponse = buildPrecommitInteractionPackCatalog();
+  const packs = Array.isArray(catalogResponse.precommit_packs) ? catalogResponse.precommit_packs : [];
+  return {
+    ok: true,
+    brand: catalogResponse.brand,
+    product: catalogResponse.product,
+    default_payment_protocol: catalogResponse.default_payment_protocol,
+    default_settlement_mode: catalogResponse.default_settlement_mode,
+    precommit_pack_count: packs.length,
+    precommit_pack_refs: packs.map((entry) => entry && entry.precommit_pack_ref).filter(Boolean),
+    categories: Array.from(new Set(packs.map((entry) => entry && entry.category).filter(Boolean))),
+    precommit_packs: packs
+  };
+}
+
+function summarizeInteractionSpinePaths() {
+  const catalogResponse = buildInteractionSpinePathCatalog();
+  const paths = Array.isArray(catalogResponse.spine_paths) ? catalogResponse.spine_paths : [];
+  return {
+    ok: true,
+    brand: catalogResponse.brand,
+    product: catalogResponse.product,
+    default_payment_protocol: catalogResponse.default_payment_protocol,
+    default_settlement_mode: catalogResponse.default_settlement_mode,
+    spine_path_count: paths.length,
+    spine_path_refs: paths.map((entry) => entry && entry.spine_path_ref).filter(Boolean),
+    categories: Array.from(new Set(paths.map((entry) => entry && entry.category).filter(Boolean))),
+    spine_paths: paths
+  };
+}
+
 function getTransactionClassPack(ref) {
   const normalized = String(ref || "").trim();
   if (!normalized) return null;
   return buildTransactionClassPacks().find((entry) => entry && entry.class_pack_ref === normalized) || null;
 }
 
+function getPrecommitInteractionPack(ref) {
+  const normalized = String(ref || "").trim();
+  if (!normalized) return null;
+  return buildPrecommitInteractionPacks().find((entry) => entry && entry.precommit_pack_ref === normalized) || null;
+}
+
+function getInteractionSpinePath(ref) {
+  const normalized = String(ref || "").trim();
+  if (!normalized) return null;
+  return buildInteractionSpinePaths().find((entry) => entry && entry.spine_path_ref === normalized) || null;
+}
+
 function buildCatalogResponse() {
   return {
     ok: true,
@@ -559,11 +748,15 @@ module.exports = {
   buildDefaultTransactionEconomics,
   buildDefaultTransactionCenter,
   buildDefaultTransactionGuidedLoopCatalog,
+  buildInteractionSpinePathCatalog,
+  buildPrecommitInteractionPackCatalog,
   buildDefaultTransactionTaskPackCatalog,
   buildTransactionClassPackCatalog,
   getCatalog,
   getDefaultTransactionGuidedLoop,
   getDefaultTransactionTaskPack,
+  getInteractionSpinePath,
+  getPrecommitInteractionPack,
   getTransactionClassPack,
   getTaskDetail,
   getWorkflowDetail,
@@ -573,5 +766,7 @@ module.exports = {
   summarizeDefaultTransactionEconomics,
   summarizeDefaultTransactionGuidedLoops,
   summarizeDefaultTransactionTaskPacks,
+  summarizeInteractionSpinePaths,
+  summarizePrecommitInteractionPacks,
   summarizeTransactionClassPacks
 };

package/lib/commerce_client.js

@@ -2652,6 +2652,54 @@ class CommerceClient {
     return result && result.data && result.data.class_pack ? result.data.class_pack : null;
   }
 
+  async getPrecommitInteractionPacks(forceRefresh) {
+    if (!forceRefresh && this.catalogSummaryCache && this.catalogSummaryCache.precommitPacks) {
+      return this.catalogSummaryCache.precommitPacks;
+    }
+    const result = await this.getJson("/v1/transaction-center/precommit-packs");
+    if (!forceRefresh) {
+      this.catalogSummaryCache = this.catalogSummaryCache || {};
+      this.catalogSummaryCache.precommitPacks = result.data;
+    }
+    return result.data;
+  }
+
+  async getPrecommitInteractionPacksSummary(forceRefresh) {
+    const result = await this.getJson("/v1/transaction-center/precommit-packs/summary");
+    return result && result.data ? result.data : { ok: true, precommit_pack_count: 0, precommit_pack_refs: [], precommit_packs: [] };
+  }
+
+  async getPrecommitInteractionPack(packRef, forceRefresh) {
+    const normalized = String(packRef || "").trim();
+    if (!normalized) return null;
+    const result = await this.getJson(`/v1/transaction-center/precommit-pack?ref=${encodeURIComponent(normalized)}`);
+    return result && result.data && result.data.precommit_pack ? result.data.precommit_pack : null;
+  }
+
+  async getInteractionSpinePaths(forceRefresh) {
+    if (!forceRefresh && this.catalogSummaryCache && this.catalogSummaryCache.spinePaths) {
+      return this.catalogSummaryCache.spinePaths;
+    }
+    const result = await this.getJson("/v1/transaction-center/spine-paths");
+    if (!forceRefresh) {
+      this.catalogSummaryCache = this.catalogSummaryCache || {};
+      this.catalogSummaryCache.spinePaths = result.data;
+    }
+    return result.data;
+  }
+
+  async getInteractionSpinePathsSummary(forceRefresh) {
+    const result = await this.getJson("/v1/transaction-center/spine-paths/summary");
+    return result && result.data ? result.data : { ok: true, spine_path_count: 0, spine_path_refs: [], spine_paths: [] };
+  }
+
+  async getInteractionSpinePath(pathRef, forceRefresh) {
+    const normalized = String(pathRef || "").trim();
+    if (!normalized) return null;
+    const result = await this.getJson(`/v1/transaction-center/spine-path?ref=${encodeURIComponent(normalized)}`);
+    return result && result.data && result.data.spine_path ? result.data.spine_path : null;
+  }
+
   async listSettlementPayees(forceRefresh) {
     const summary = await this.getSettlementPayeeSummaries(forceRefresh);
     return extractSummaryValues(summary, "settlement_payees", "payee_agent_id");
@@ -3906,6 +3954,64 @@ class CommerceClient {
     };
   }
 
+  async runPrecommitInteractionPack(packRef, body, options) {
+    const opts = options || {};
+    return this.runNamedTaskRoute("/v1/transaction-center/precommit-packs/run", {
+      command: opts.command || String(packRef || "").trim() || "precommit.pack.run",
+      precommit_pack_ref: String(packRef || "").trim(),
+      body: body || {},
+      callback_url: opts.callbackUrl || null,
+      settlement_mode: opts.settlementMode || null,
+      payment_protocol: opts.paymentProtocol || null,
+      protocol: opts.protocol || null,
+      integration_id: opts.integrationId || null,
+      integration_ids: Array.isArray(opts.integrationIds) ? opts.integrationIds : [],
+      integration_context: opts.integrationContext || null
+    });
+  }
+
+  async runPrecommitInteractionPackSummary(packRef, body, options) {
+    const result = await this.runPrecommitInteractionPack(packRef, body, options);
+    return {
+      ok: result && result.ok === true,
+      precommit_pack_ref: result && result.precommit_pack ? result.precommit_pack.precommit_pack_ref || null : null,
+      readiness_kind: result && result.precommit_pack ? result.precommit_pack.readiness_kind || null : null,
+      result_set_summary: result && result.result_set_summary ? result.result_set_summary : null,
+      linked_record_summary: result && result.linked_record_summary ? result.linked_record_summary : null,
+      activity_summary: result && result.activity_summary ? result.activity_summary : null,
+      precommit_readiness_summary: result && result.precommit_readiness_summary ? result.precommit_readiness_summary : null
+    };
+  }
+
+  async runInteractionSpinePath(pathRef, body, options) {
+    const opts = options || {};
+    return this.runNamedTaskRoute("/v1/transaction-center/spine-paths/run", {
+      command: opts.command || String(pathRef || "").trim() || "spine.path.run",
+      spine_path_ref: String(pathRef || "").trim(),
+      body: body || {},
+      callback_url: opts.callbackUrl || null,
+      settlement_mode: opts.settlementMode || null,
+      payment_protocol: opts.paymentProtocol || null,
+      protocol: opts.protocol || null,
+      integration_id: opts.integrationId || null,
+      integration_ids: Array.isArray(opts.integrationIds) ? opts.integrationIds : [],
+      integration_context: opts.integrationContext || null
+    });
+  }
+
+  async runInteractionSpinePathSummary(pathRef, body, options) {
+    const result = await this.runInteractionSpinePath(pathRef, body, options);
+    return {
+      ok: result && result.ok === true,
+      spine_path_ref: result && result.spine_path ? result.spine_path.spine_path_ref || null : null,
+      committed_ref: result && result.spine_path ? result.spine_path.committed_ref || null : null,
+      result_set_summary: result && result.result_set_summary ? result.result_set_summary : null,
+      linked_record_summary: result && result.linked_record_summary ? result.linked_record_summary : null,
+      activity_summary: result && result.activity_summary ? result.activity_summary : null,
+      spine_summary: result && result.spine_summary ? result.spine_summary : null
+    };
+  }
+
   async runNamedTaskRoute(path, payload) {
     if (!this.apiKey || !this.walletId || !this.walletSecret) {
       throw new Error("named task routes require apiKey, walletId, and walletSecret");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xytara",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Machine commerce SDK for discovery, quoting, execution, lifecycle inspection, and adapters.",
   "main": "index.js",
   "type": "commonjs",

package/server.js

@@ -7,11 +7,15 @@ const {
   buildDefaultTransactionCenter,
   buildDefaultTransactionEconomics,
   buildDefaultTransactionGuidedLoopCatalog,
+  buildInteractionSpinePathCatalog,
+  buildPrecommitInteractionPackCatalog,
   buildDefaultTransactionTaskPackCatalog,
   buildTransactionClassPackCatalog,
   getCatalog,
   getDefaultTransactionGuidedLoop,
   getDefaultTransactionTaskPack,
+  getInteractionSpinePath,
+  getPrecommitInteractionPack,
   getTransactionClassPack,
   getTaskDetail,
   getWorkflowDetail,
@@ -20,7 +24,9 @@ const {
   summarizeDefaultTransactionCenter,
   summarizeDefaultTransactionEconomics,
   summarizeDefaultTransactionGuidedLoops,
+  summarizeInteractionSpinePaths,
   summarizeDefaultTransactionTaskPacks,
+  summarizePrecommitInteractionPacks,
   summarizeTransactionClassPacks
 } = require("./lib/catalog_contract");
 const {
@@ -506,6 +512,276 @@ function buildTransactionClassPackRunPayload(body) {
   return null;
 }
 
+function buildPrecommitInteractionPackRunPayload(body) {
+  const requestBody = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const packBody = requestBody.body && typeof requestBody.body === "object" && !Array.isArray(requestBody.body)
+    ? requestBody.body
+    : requestBody;
+  const packRef = String(requestBody.precommit_pack_ref || "").trim();
+  const integrationIds = Array.isArray(requestBody.integration_ids) && requestBody.integration_ids.length > 0
+    ? requestBody.integration_ids
+    : ["builtin.payment.x402", "builtin.settlement.chain"];
+
+  if (packRef === "precommit.a2a.settlement.readiness") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "a2a.negotiate",
+        body: {
+          counterparty_agent_id: packBody.counterparty_agent_id,
+          task_pack_ref: packBody.task_pack_ref,
+          negotiation_mode: packBody.negotiation_mode
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: packBody.source_zone_id,
+          target_zone_id: packBody.target_zone_id,
+          interaction_class: packBody.interaction_class
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "a2a.commit",
+        body: {
+          negotiation_id: packBody.negotiation_id,
+          intent_id: packBody.intent_id
+        }
+      }
+    ], {
+      ...requestBody,
+      ...packBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || packRef);
+  }
+
+  if (packRef === "precommit.a2c.tooling.readiness") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "a2c.session.open",
+        body: {
+          agent_id: packBody.agent_id,
+          channel_ref: packBody.channel_ref
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "a2c.pack.preview",
+        body: {
+          agent_id: packBody.agent_id,
+          pack_ref: packBody.pack_ref
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: packBody.source_zone_id,
+          target_zone_id: packBody.target_zone_id,
+          interaction_class: packBody.interaction_class
+        }
+      }
+    ], {
+      ...requestBody,
+      ...packBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || packRef);
+  }
+
+  if (packRef === "precommit.job.commitment.readiness") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "jobs.quote",
+        body: {
+          job_type: packBody.job_type
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: packBody.source_zone_id,
+          target_zone_id: packBody.target_zone_id,
+          interaction_class: packBody.interaction_class
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "jobs.reserve",
+        body: {
+          job_id: packBody.job_id
+        }
+      }
+    ], {
+      ...requestBody,
+      ...packBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || packRef);
+  }
+
+  return null;
+}
+
+function buildInteractionSpinePathRunPayload(body) {
+  const requestBody = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+  const pathBody = requestBody.body && typeof requestBody.body === "object" && !Array.isArray(requestBody.body)
+    ? requestBody.body
+    : requestBody;
+  const pathRef = String(requestBody.spine_path_ref || "").trim();
+  const integrationIds = Array.isArray(requestBody.integration_ids) && requestBody.integration_ids.length > 0
+    ? requestBody.integration_ids
+    : ["builtin.payment.x402", "builtin.settlement.chain"];
+
+  if (pathRef === "spine.a2a.settlement") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "a2a.negotiate",
+        body: {
+          counterparty_agent_id: pathBody.counterparty_agent_id,
+          task_pack_ref: pathBody.task_pack_ref,
+          negotiation_mode: pathBody.negotiation_mode
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: pathBody.source_zone_id,
+          target_zone_id: pathBody.target_zone_id,
+          interaction_class: pathBody.interaction_class
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "a2a.commit",
+        body: {
+          negotiation_id: pathBody.negotiation_id,
+          intent_id: pathBody.intent_id
+        }
+      },
+      {
+        task_id: "task_4",
+        task_ref: "settlement.submit",
+        body: {
+          intent_id: pathBody.intent_id
+        }
+      }
+    ], {
+      ...requestBody,
+      ...pathBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || pathRef);
+  }
+
+  if (pathRef === "spine.a2c.tooling") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "a2c.session.open",
+        body: {
+          agent_id: pathBody.agent_id,
+          channel_ref: pathBody.channel_ref
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "a2c.pack.preview",
+        body: {
+          agent_id: pathBody.agent_id,
+          pack_ref: pathBody.pack_ref
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: pathBody.source_zone_id,
+          target_zone_id: pathBody.target_zone_id,
+          interaction_class: pathBody.interaction_class
+        }
+      },
+      {
+        task_id: "task_4",
+        task_ref: "adapter.mcp.invoke",
+        body: {
+          tool_name: pathBody.tool_name,
+          arguments: pathBody.arguments && typeof pathBody.arguments === "object" && !Array.isArray(pathBody.arguments)
+            ? pathBody.arguments
+            : {}
+        }
+      }
+    ], {
+      ...requestBody,
+      ...pathBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || pathRef);
+  }
+
+  if (pathRef === "spine.job.commitment") {
+    return buildNamedTaskSetPayload([
+      {
+        task_id: "task_1",
+        task_ref: "jobs.quote",
+        body: {
+          job_type: pathBody.job_type
+        }
+      },
+      {
+        task_id: "task_2",
+        task_ref: "admission.preview",
+        body: {
+          source_zone_id: pathBody.source_zone_id,
+          target_zone_id: pathBody.target_zone_id,
+          interaction_class: pathBody.interaction_class
+        }
+      },
+      {
+        task_id: "task_3",
+        task_ref: "jobs.reserve",
+        body: {
+          job_id: pathBody.job_id
+        }
+      },
+      {
+        task_id: "task_4",
+        task_ref: "jobs.commit",
+        body: {
+          job_id: pathBody.job_id
+        }
+      }
+    ], {
+      ...requestBody,
+      ...pathBody,
+      protocol: requestBody.protocol || null,
+      payment_protocol: requestBody.payment_protocol || "x402",
+      integration_ids: integrationIds,
+      settlement_mode: requestBody.settlement_mode || "evm_payment"
+    }, requestBody.command || pathRef);
+  }
+
+  return null;
+}
+
 function listTransactionRecords(filters) {
   const transactions = Array.from(state.transactions.values()).map((item) => item.transaction);
   return listRecords(new Map(transactions.map((item) => [item.transaction_id, item])), filters);
@@ -652,6 +928,55 @@ function buildProofHandoffSummary(result, sourceRef) {
   };
 }
 
+function buildPrecommitReadinessSummary(result, pack) {
+  const resultSet = buildResultSetFromCommandResult(result);
+  const transaction = resultSet.transaction || {};
+  const taskRefs = transaction.execution && transaction.execution.results_by_task_id
+    ? Object.values(transaction.execution.results_by_task_id).map((entry) => entry && entry.task_ref).filter(Boolean)
+    : [];
+  const admissionChecked = taskRefs.includes("admission.preview");
+  const negotiationSignals = taskRefs.filter((ref) => ref === "a2a.negotiate" || ref === "a2c.session.open");
+  const commitmentSignals = taskRefs.filter((ref) => ref === "a2a.commit" || ref === "a2c.pack.preview" || ref === "jobs.reserve");
+  const readinessPosture = admissionChecked && commitmentSignals.length > 0
+    ? "ready_for_committed_run"
+    : negotiationSignals.length > 0
+      ? "negotiation_in_progress"
+      : "precommit_partial";
+  return {
+    ok: true,
+    precommit_pack_ref: pack && pack.precommit_pack_ref ? pack.precommit_pack_ref : null,
+    readiness_kind: pack && pack.readiness_kind ? pack.readiness_kind : null,
+    protocol: transaction.protocol || (pack && pack.protocol ? pack.protocol : null),
+    payment_protocol: transaction.payment && transaction.payment.protocol
+      ? transaction.payment.protocol
+      : (pack && pack.default_payment_protocol ? pack.default_payment_protocol : null),
+    settlement_mode: transaction.settlement && transaction.settlement.mode
+      ? transaction.settlement.mode
+      : (pack && pack.default_settlement_mode ? pack.default_settlement_mode : null),
+    task_refs: taskRefs,
+    negotiation_signal_count: negotiationSignals.length,
+    commitment_signal_count: commitmentSignals.length,
+    admission_checked: admissionChecked,
+    readiness_posture: readinessPosture,
+    recommended_next_surface: pack && pack.recommended_next_surface ? pack.recommended_next_surface : null,
+    recommended_next_ref: pack && pack.recommended_next_ref ? pack.recommended_next_ref : null,
+    transaction_id: transaction.transaction_id || null
+  };
+}
+
+function buildInteractionSpineSummary(result, path) {
+  const precommitPack = path && path.precommit_pack_ref ? getPrecommitInteractionPack(path.precommit_pack_ref) : null;
+  return {
+    ok: true,
+    spine_path_ref: path && path.spine_path_ref ? path.spine_path_ref : null,
+    precommit_pack_ref: path && path.precommit_pack_ref ? path.precommit_pack_ref : null,
+    committed_ref: path && path.committed_ref ? path.committed_ref : null,
+    proof_followthrough: path && path.proof_followthrough ? path.proof_followthrough : null,
+    precommit_readiness_summary: buildPrecommitReadinessSummary(result, precommitPack),
+    proof_handoff_summary: buildProofHandoffSummary(result, path && path.committed_ref ? path.committed_ref : null)
+  };
+}
+
 function buildOperationsDashboard(filters) {
   const disputes = listRecords(state.disputes, filters);
   const refunds = listRecords(state.refunds, filters);
@@ -760,6 +1085,46 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/precommit-packs") {
+    sendJson(res, 200, buildPrecommitInteractionPackCatalog());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/precommit-packs/summary") {
+    sendJson(res, 200, summarizePrecommitInteractionPacks());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/precommit-pack") {
+    const pack = getPrecommitInteractionPack(url.searchParams.get("ref"));
+    if (!pack) {
+      sendJson(res, 404, { ok: false, error: "precommit_pack_not_found" });
+      return;
+    }
+    sendJson(res, 200, { ok: true, precommit_pack: pack });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/spine-paths") {
+    sendJson(res, 200, buildInteractionSpinePathCatalog());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/spine-paths/summary") {
+    sendJson(res, 200, summarizeInteractionSpinePaths());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/spine-path") {
+    const path = getInteractionSpinePath(url.searchParams.get("ref"));
+    if (!path) {
+      sendJson(res, 404, { ok: false, error: "spine_path_not_found" });
+      return;
+    }
+    sendJson(res, 200, { ok: true, spine_path: path });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/v1/transaction-center/transaction-class-packs") {
     sendJson(res, 200, buildTransactionClassPackCatalog());
     return;
@@ -1287,6 +1652,66 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "POST" && url.pathname === "/v1/transaction-center/precommit-packs/run") {
+    const body = await readJsonBody(req);
+    const packRef = String(body && body.precommit_pack_ref || "").trim();
+    const pack = getPrecommitInteractionPack(packRef);
+    if (!pack) {
+      sendJson(res, 404, { ok: false, error: "precommit_pack_not_found" });
+      return;
+    }
+    const payload = buildPrecommitInteractionPackRunPayload(body);
+    if (!payload) {
+      sendJson(res, 404, { ok: false, error: "precommit_pack_not_found" });
+      return;
+    }
+    const result = executeCommandRequest(state, payload, req.headers);
+    if (result.status !== 200) {
+      sendJson(res, result.status, result.payload);
+      return;
+    }
+    sendJson(res, 200, {
+      ok: true,
+      precommit_pack: pack,
+      result: result.payload,
+      result_set_summary: summarizeResultSetPayload(buildResultSetFromCommandResult(result.payload)),
+      linked_record_summary: summarizeLinkedRecordSetPayload(buildLinkedRecordSetFromCommandResult(result.payload)),
+      activity_summary: summarizeActivitySnapshotPayload(buildActivitySnapshotFromCommandResult(result.payload)),
+      precommit_readiness_summary: buildPrecommitReadinessSummary(result.payload, pack)
+    });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/v1/transaction-center/spine-paths/run") {
+    const body = await readJsonBody(req);
+    const pathRef = String(body && body.spine_path_ref || "").trim();
+    const path = getInteractionSpinePath(pathRef);
+    if (!path) {
+      sendJson(res, 404, { ok: false, error: "spine_path_not_found" });
+      return;
+    }
+    const payload = buildInteractionSpinePathRunPayload(body);
+    if (!payload) {
+      sendJson(res, 404, { ok: false, error: "spine_path_not_found" });
+      return;
+    }
+    const result = executeCommandRequest(state, payload, req.headers);
+    if (result.status !== 200) {
+      sendJson(res, result.status, result.payload);
+      return;
+    }
+    sendJson(res, 200, {
+      ok: true,
+      spine_path: path,
+      result: result.payload,
+      result_set_summary: summarizeResultSetPayload(buildResultSetFromCommandResult(result.payload)),
+      linked_record_summary: summarizeLinkedRecordSetPayload(buildLinkedRecordSetFromCommandResult(result.payload)),
+      activity_summary: summarizeActivitySnapshotPayload(buildActivitySnapshotFromCommandResult(result.payload)),
+      spine_summary: buildInteractionSpineSummary(result.payload, path)
+    });
+    return;
+  }
+
   if (req.method === "POST" && url.pathname === "/v1/transaction-center/default-loops/run") {
     const body = await readJsonBody(req);
     const loopRef = String(body && body.loop_ref || "").trim();