xytara 2.2.0 → 2.4.0

package/lib/capability_registry.js

@@ -0,0 +1,572 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const {
+  getCatalog,
+  summarizeCatalog,
+  buildDefaultTransactionTaskPackCatalog,
+  summarizeDefaultTransactionTaskPacks,
+  buildTransactionClassPackCatalog,
+  summarizeTransactionClassPacks,
+  buildPrecommitInteractionPackCatalog,
+  summarizePrecommitInteractionPacks,
+  buildInteractionSpinePathCatalog,
+  summarizeInteractionSpinePaths,
+  buildDefaultTransactionGuidedLoopCatalog,
+  summarizeDefaultTransactionGuidedLoops,
+  buildInteractionResultPackageCatalog,
+  summarizeInteractionResultPackages,
+  buildInteractionResultPackageContinuationCatalog,
+  summarizeInteractionResultPackageContinuations
+} = require("./catalog_contract");
+const {
+  buildAdapterPack,
+  summarizeAdapterPack
+} = require("./adapter_pack");
+const {
+  buildAdapterPromotionPack,
+  summarizeAdapterPromotionPack
+} = require("./adapter_promotion_pack");
+const {
+  buildAdapterPartnerPack,
+  summarizeAdapterPartnerPack
+} = require("./adapter_partner_pack");
+const {
+  buildPartnerIntelligencePack
+} = require("./partner_intelligence");
+
+function buildCapabilityRegistrySummary() {
+  const catalogSummary = summarizeCatalog();
+  const taskPackSummary = summarizeDefaultTransactionTaskPacks();
+  const classPackSummary = summarizeTransactionClassPacks();
+  const precommitSummary = summarizePrecommitInteractionPacks();
+  const spineSummary = summarizeInteractionSpinePaths();
+  const loopSummary = summarizeDefaultTransactionGuidedLoops();
+  const resultPackageSummary = summarizeInteractionResultPackages();
+  const continuationSummary = summarizeInteractionResultPackageContinuations();
+  const adapterSummary = summarizeAdapterPack();
+  const adapterPromotionSummary = summarizeAdapterPromotionPack();
+  const adapterPartnerSummary = summarizeAdapterPartnerPack();
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-summary",
+    summary_version: "xytara-capability-registry-summary-v1",
+    registry_state: "explicit_runtime_registry_present",
+    counts: {
+      capability_count: Array.isArray(catalogSummary.tasks) ? catalogSummary.tasks.length : 0,
+      workflow_count: Array.isArray(catalogSummary.workflow_summaries) ? catalogSummary.workflow_summaries.length : 0,
+      task_pack_count: Number(taskPackSummary.pack_count || 0),
+      class_pack_count: Number(classPackSummary.class_pack_count || 0),
+      precommit_pack_count: Number(precommitSummary.precommit_pack_count || 0),
+      spine_path_count: Number(spineSummary.path_count || 0),
+      loop_count: Number(loopSummary.loop_count || 0),
+      result_package_count: Number(resultPackageSummary.result_package_count || 0),
+      continuation_count: Number(continuationSummary.continuation_count || 0),
+      adapter_class_count: Number(adapterSummary.starter_class_count || 0),
+      adapter_promotion_step_count: Number(adapterPromotionSummary.maturity_step_count || 0),
+      adapter_partner_audience_count: Number(adapterPartnerSummary.audience_count || 0)
+    },
+    registry_posture: {
+      catalog_state: "task_and_workflow_registry_present",
+      execution_pack_state: "task_class_precommit_and_loop_packs_present",
+      continuation_state: "result_package_and_continuation_registry_present",
+      adapter_state: "adapter_registration_promotion_and_partner_registry_present"
+    },
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      catalog_summary_ref: "/v1/catalog/summary",
+      task_packs_summary_ref: "/v1/transaction-center/task-packs/summary",
+      class_packs_summary_ref: "/v1/transaction-center/transaction-class-packs/summary",
+      precommit_packs_summary_ref: "/v1/transaction-center/precommit-packs/summary",
+      adapter_pack_summary_ref: "/v1/adapter-pack/summary",
+      adapter_promotion_summary_ref: "/v1/adapter-promotion/summary",
+      adapter_partner_summary_ref: "/v1/adapter-partners/summary"
+    }
+  };
+}
+
+function buildCapabilityRegistryBundle() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry",
+    bundle_version: "xytara-capability-registry-bundle-v1",
+    capability_registry_summary: buildCapabilityRegistrySummary(),
+    catalog: getCatalog(),
+    catalog_summary: summarizeCatalog(),
+    task_pack_catalog: buildDefaultTransactionTaskPackCatalog(),
+    task_pack_summary: summarizeDefaultTransactionTaskPacks(),
+    class_pack_catalog: buildTransactionClassPackCatalog(),
+    class_pack_summary: summarizeTransactionClassPacks(),
+    precommit_pack_catalog: buildPrecommitInteractionPackCatalog(),
+    precommit_pack_summary: summarizePrecommitInteractionPacks(),
+    spine_path_catalog: buildInteractionSpinePathCatalog(),
+    spine_path_summary: summarizeInteractionSpinePaths(),
+    loop_catalog: buildDefaultTransactionGuidedLoopCatalog(),
+    loop_summary: summarizeDefaultTransactionGuidedLoops(),
+    result_package_catalog: buildInteractionResultPackageCatalog(),
+    result_package_summary: summarizeInteractionResultPackages(),
+    continuation_catalog: buildInteractionResultPackageContinuationCatalog(),
+    continuation_summary: summarizeInteractionResultPackageContinuations(),
+    adapter_pack: buildAdapterPack(),
+    adapter_pack_summary: summarizeAdapterPack(),
+    adapter_promotion_pack: buildAdapterPromotionPack(),
+    adapter_promotion_summary: summarizeAdapterPromotionPack(),
+    adapter_partner_pack: buildAdapterPartnerPack(),
+    adapter_partner_summary: summarizeAdapterPartnerPack(),
+    linked_surfaces: {
+      capability_registry_summary_ref: "/v1/capability-registry/summary",
+      catalog_ref: "/v1/catalog",
+      task_pack_catalog_ref: "/v1/transaction-center/task-packs",
+      class_pack_catalog_ref: "/v1/transaction-center/transaction-class-packs",
+      precommit_pack_catalog_ref: "/v1/transaction-center/precommit-packs",
+      adapter_pack_ref: "/v1/adapter-pack",
+      adapter_promotion_ref: "/v1/adapter-promotion",
+      adapter_partner_ref: "/v1/adapter-partners"
+    }
+  };
+}
+
+function buildCapabilityRegistryClassificationSummary() {
+  const catalog = getCatalog();
+  const taskCategories = new Map();
+  const workflowCategories = new Map();
+  const taskLatencies = new Map();
+  const taskFailurePostures = new Map();
+
+  for (const task of Array.isArray(catalog.tasks) ? catalog.tasks : []) {
+    const category = task && task.public_category ? task.public_category : "unknown";
+    const latency = task && task.latency_class ? task.latency_class : "unknown";
+    const failurePosture = task && task.failure_posture ? task.failure_posture : "unknown";
+    taskCategories.set(category, Number(taskCategories.get(category) || 0) + 1);
+    taskLatencies.set(latency, Number(taskLatencies.get(latency) || 0) + 1);
+    taskFailurePostures.set(failurePosture, Number(taskFailurePostures.get(failurePosture) || 0) + 1);
+  }
+
+  for (const workflow of Array.isArray(catalog.workflows) ? catalog.workflows : []) {
+    const category = workflow && workflow.category ? workflow.category : "unknown";
+    workflowCategories.set(category, Number(workflowCategories.get(category) || 0) + 1);
+  }
+
+  const precommitCatalog = buildPrecommitInteractionPackCatalog();
+  const spineCatalog = buildInteractionSpinePathCatalog();
+  const protocols = Array.from(new Set(
+    []
+      .concat(Array.isArray(precommitCatalog.precommit_packs) ? precommitCatalog.precommit_packs : [])
+      .concat(Array.isArray(spineCatalog.paths) ? spineCatalog.paths : [])
+      .map((entry) => entry && entry.protocol ? entry.protocol : null)
+      .filter(Boolean)
+  ));
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-classification-summary",
+    summary_version: "xytara-capability-registry-classification-summary-v1",
+    task_categories: Array.from(taskCategories.entries()).map(([category, task_count]) => ({ category, task_count })),
+    workflow_categories: Array.from(workflowCategories.entries()).map(([category, workflow_count]) => ({ category, workflow_count })),
+    task_latency_classes: Array.from(taskLatencies.entries()).map(([latency_class, task_count]) => ({ latency_class, task_count })),
+    task_failure_postures: Array.from(taskFailurePostures.entries()).map(([failure_posture, task_count]) => ({ failure_posture, task_count })),
+    protocol_families: protocols,
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      capability_registry_lineage_summary_ref: "/v1/capability-registry/lineage-summary",
+      catalog_summary_ref: "/v1/catalog/summary"
+    }
+  };
+}
+
+function buildCapabilityRegistryLineageSummary() {
+  const catalog = getCatalog();
+  const taskPackCatalog = buildDefaultTransactionTaskPackCatalog();
+  const classPackCatalog = buildTransactionClassPackCatalog();
+  const precommitCatalog = buildPrecommitInteractionPackCatalog();
+  const spineCatalog = buildInteractionSpinePathCatalog();
+  const loopCatalog = buildDefaultTransactionGuidedLoopCatalog();
+
+  const lineageRows = [];
+
+  for (const workflow of Array.isArray(catalog.workflows) ? catalog.workflows : []) {
+    lineageRows.push({
+      source_kind: "workflow",
+      source_ref: workflow.workflow_ref,
+      relationship: "contains_tasks",
+      target_kind: "task",
+      target_refs: Array.isArray(workflow.task_refs) ? workflow.task_refs : []
+    });
+  }
+
+  for (const pack of Array.isArray(taskPackCatalog.packs) ? taskPackCatalog.packs : []) {
+    lineageRows.push({
+      source_kind: "task_pack",
+      source_ref: pack.pack_ref,
+      relationship: pack.workflow_ref ? "binds_workflow_and_tasks" : "binds_tasks",
+      target_kind: pack.workflow_ref ? "workflow_and_tasks" : "task",
+      target_refs: pack.workflow_ref
+        ? [pack.workflow_ref].concat(Array.isArray(pack.task_refs) ? pack.task_refs : [])
+        : Array.isArray(pack.task_refs) ? pack.task_refs : []
+    });
+  }
+
+  for (const pack of Array.isArray(classPackCatalog.packs) ? classPackCatalog.packs : []) {
+    lineageRows.push({
+      source_kind: "class_pack",
+      source_ref: pack.class_pack_ref,
+      relationship: "groups_workflow_and_tasks",
+      target_kind: "workflow_and_tasks",
+      target_refs: [pack.workflow_ref].concat(Array.isArray(pack.task_refs) ? pack.task_refs : []).filter(Boolean)
+    });
+  }
+
+  for (const pack of Array.isArray(precommitCatalog.packs) ? precommitCatalog.packs : []) {
+    lineageRows.push({
+      source_kind: "precommit_pack",
+      source_ref: pack.precommit_pack_ref,
+      relationship: "prepares_next_ref",
+      target_kind: "next_ref",
+      target_refs: [pack.recommended_next_ref].filter(Boolean)
+    });
+  }
+
+  for (const path of Array.isArray(spineCatalog.paths) ? spineCatalog.paths : []) {
+    lineageRows.push({
+      source_kind: "spine_path",
+      source_ref: path.spine_path_ref,
+      relationship: "stitches_tasks",
+      target_kind: "task",
+      target_refs: Array.isArray(path.task_refs) ? path.task_refs : []
+    });
+  }
+
+  for (const loop of Array.isArray(loopCatalog.loops) ? loopCatalog.loops : []) {
+    lineageRows.push({
+      source_kind: "guided_loop",
+      source_ref: loop.loop_ref,
+      relationship: "drives_pack",
+      target_kind: "pack",
+      target_refs: [loop.pack_ref].filter(Boolean)
+    });
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-lineage-summary",
+    summary_version: "xytara-capability-registry-lineage-summary-v1",
+    lineage_row_count: lineageRows.length,
+    lineage_rows: lineageRows,
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      capability_registry_summary_ref: "/v1/capability-registry/summary",
+      capability_registry_classification_summary_ref: "/v1/capability-registry/classification-summary"
+    }
+  };
+}
+
+function buildCapabilityRegistryOperatorBundle(state, input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
+  const summary = buildCapabilityRegistrySummary();
+  const bundle = buildCapabilityRegistryBundle();
+  const partnerIntelligence = buildPartnerIntelligencePack();
+
+  let recommendedRegistryMotion = "maintain_explicit_runtime_registry";
+  if (summary.counts.adapter_promotion_step_count < 5) {
+    recommendedRegistryMotion = "strengthen_adapter_registry_promotion_path";
+  } else if (summary.counts.precommit_pack_count < 3 || summary.counts.class_pack_count < 5) {
+    recommendedRegistryMotion = "strengthen_execution_pack_coverage";
+  } else if (partnerIntelligence.onboarding_friction_state !== "low") {
+    recommendedRegistryMotion = "tighten_registry_entry_clarity";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-operator-bundle",
+    bundle_version: "xytara-capability-registry-operator-bundle-v1",
+    account_id: accountId,
+    operator_posture: {
+      registry_state: summary.registry_state,
+      catalog_state: summary.registry_posture.catalog_state,
+      adapter_state: summary.registry_posture.adapter_state,
+      partner_readiness_state: partnerIntelligence.partner_readiness_state,
+      recommended_registry_motion: recommendedRegistryMotion
+    },
+    capability_registry_summary: summary,
+    capability_registry_bundle: bundle,
+    capability_registry_classification_summary: buildCapabilityRegistryClassificationSummary(),
+    capability_registry_lineage_summary: buildCapabilityRegistryLineageSummary(),
+    partner_intelligence: partnerIntelligence,
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      capability_registry_summary_ref: "/v1/capability-registry/summary",
+      capability_registry_classification_summary_ref: "/v1/capability-registry/classification-summary",
+      capability_registry_lineage_summary_ref: "/v1/capability-registry/lineage-summary",
+      partner_intelligence_ref: "/v1/partner-intelligence",
+      adapter_partner_summary_ref: "/v1/adapter-partners/summary"
+    }
+  };
+}
+
+function buildCapabilityRegistryPolicyPack(state, input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
+  const summary = buildCapabilityRegistrySummary();
+  const classification = buildCapabilityRegistryClassificationSummary();
+  const lineage = buildCapabilityRegistryLineageSummary();
+  const operatorBundle = buildCapabilityRegistryOperatorBundle(state, { account_id: accountId });
+  const partnerIntelligence = buildPartnerIntelligencePack();
+  const policyTemplates = [
+    {
+      template_id: "runtime_registry_maintenance",
+      recommended_for: "maintaining a broad explicit runtime registry with stable entry paths",
+      focus_surfaces: [
+        "/v1/capability-registry",
+        "/v1/capability-registry/classification-summary",
+        "/v1/capability-registry/lineage-summary"
+      ],
+      operator_actions: [
+        "review capability coverage counts",
+        "check workflow-to-task lineage continuity",
+        "preserve explicit runtime registry posture"
+      ]
+    },
+    {
+      template_id: "execution_pack_coverage_strengthening",
+      recommended_for: "strengthening task/class/precommit/loop pack coverage across the runtime surface",
+      focus_surfaces: [
+        "/v1/transaction-center/task-packs/summary",
+        "/v1/transaction-center/transaction-class-packs/summary",
+        "/v1/transaction-center/precommit-packs/summary",
+        "/v1/capability-registry/lineage-summary"
+      ],
+      operator_actions: [
+        "tighten class and precommit pack breadth",
+        "fill missing execution path coverage",
+        "review workflow-to-pack lineage gaps"
+      ]
+    },
+    {
+      template_id: "adapter_registry_promotion",
+      recommended_for: "lifting extension and partner-facing registry posture for outside builders",
+      focus_surfaces: [
+        "/v1/adapter-pack/summary",
+        "/v1/adapter-promotion/summary",
+        "/v1/adapter-partners/summary",
+        "/v1/partner-intelligence"
+      ],
+      operator_actions: [
+        "strengthen adapter promotion posture",
+        "prioritize partner-ready extension families",
+        "improve adapter author success ladder"
+      ]
+    },
+    {
+      template_id: "entry_clarity_tightening",
+      recommended_for: "reducing first-contact friction across the public runtime capability surface",
+      focus_surfaces: [
+        "/v1/catalog/summary",
+        "/v1/capability-registry/summary",
+        "/v1/capability-registry/operator-bundle/summary",
+        "/v1/partner-intelligence/summary"
+      ],
+      operator_actions: [
+        "reduce entry-path ambiguity",
+        "tighten public capability grouping",
+        "align runtime registry with adoption posture"
+      ]
+    }
+  ];
+
+  let recommendedPolicyMotion = "maintain_explicit_runtime_registry";
+  if (summary.counts.adapter_promotion_step_count < 5) {
+    recommendedPolicyMotion = "promote_adapter_registry";
+  } else if (summary.counts.precommit_pack_count < 3 || summary.counts.class_pack_count < 5) {
+    recommendedPolicyMotion = "strengthen_execution_pack_coverage";
+  } else if (partnerIntelligence.onboarding_friction_state !== "low") {
+    recommendedPolicyMotion = "tighten_registry_entry_clarity";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-policy-pack",
+    pack_version: "xytara-capability-registry-policy-pack-v1",
+    account_id: accountId,
+    capability_registry_summary: summary,
+    capability_registry_classification_summary: classification,
+    capability_registry_lineage_summary: lineage,
+    operator_posture: operatorBundle.operator_posture,
+    recommended_policy_motion: recommendedPolicyMotion,
+    policy_templates: policyTemplates,
+    policy_context: {
+      capability_count: summary.counts.capability_count,
+      workflow_count: summary.counts.workflow_count,
+      task_pack_count: summary.counts.task_pack_count,
+      class_pack_count: summary.counts.class_pack_count,
+      precommit_pack_count: summary.counts.precommit_pack_count,
+      adapter_class_count: summary.counts.adapter_class_count,
+      adapter_promotion_step_count: summary.counts.adapter_promotion_step_count,
+      partner_readiness_state: partnerIntelligence.partner_readiness_state,
+      onboarding_friction_state: partnerIntelligence.onboarding_friction_state,
+      protocol_family_count: Array.isArray(classification.protocol_families) ? classification.protocol_families.length : 0,
+      lineage_row_count: lineage.lineage_row_count
+    },
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      capability_registry_summary_ref: "/v1/capability-registry/summary",
+      capability_registry_classification_summary_ref: "/v1/capability-registry/classification-summary",
+      capability_registry_lineage_summary_ref: "/v1/capability-registry/lineage-summary",
+      capability_registry_operator_bundle_ref: `/v1/capability-registry/operator-bundle?account_id=${encodeURIComponent(accountId)}`,
+      partner_intelligence_ref: "/v1/partner-intelligence"
+    }
+  };
+}
+
+function summarizeCapabilityRegistryPolicyPack(state, input) {
+  const pack = buildCapabilityRegistryPolicyPack(state, input);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    pack_version: pack.pack_version,
+    account_id: pack.account_id,
+    recommended_policy_motion: pack.recommended_policy_motion,
+    template_count: Array.isArray(pack.policy_templates) ? pack.policy_templates.length : 0,
+    partner_readiness_state: pack.policy_context.partner_readiness_state,
+    onboarding_friction_state: pack.policy_context.onboarding_friction_state,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function buildCapabilityRegistryPolicyApplicationSummary(state, input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
+  const templateId = String(payload.template_id || "").trim();
+  const pack = buildCapabilityRegistryPolicyPack(state, { account_id: accountId });
+  const selectedTemplate = Array.isArray(pack.policy_templates)
+    ? pack.policy_templates.find((entry) => entry.template_id === templateId)
+      || pack.policy_templates.find((entry) => {
+        if (pack.recommended_policy_motion === "promote_adapter_registry") {
+          return entry.template_id === "adapter_registry_promotion";
+        }
+        if (pack.recommended_policy_motion === "strengthen_execution_pack_coverage") {
+          return entry.template_id === "execution_pack_coverage_strengthening";
+        }
+        if (pack.recommended_policy_motion === "tighten_registry_entry_clarity") {
+          return entry.template_id === "entry_clarity_tightening";
+        }
+        return entry.template_id === "runtime_registry_maintenance";
+      })
+      || pack.policy_templates[0]
+    : null;
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-policy-application-summary",
+    summary_version: "xytara-capability-registry-policy-application-summary-v1",
+    account_id: accountId,
+    recommended_policy_motion: pack.recommended_policy_motion,
+    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
+    available_template_ids: Array.isArray(pack.policy_templates)
+      ? pack.policy_templates.map((entry) => entry.template_id)
+      : [],
+    selected_template: selectedTemplate,
+    suggested_registry_targets: {
+      classification_focus: pack.policy_context.protocol_family_count > 0 ? "protocol_family_coverage_present" : "protocol_family_coverage_needs_review",
+      lineage_focus: pack.policy_context.lineage_row_count > 0 ? "lineage_present_reviewable" : "lineage_needs_buildout",
+      partner_focus: pack.policy_context.onboarding_friction_state
+    },
+    linked_surfaces: {
+      capability_registry_policy_pack_ref: `/v1/capability-registry/policy-pack?account_id=${encodeURIComponent(accountId)}`,
+      capability_registry_operator_bundle_summary_ref: `/v1/capability-registry/operator-bundle/summary?account_id=${encodeURIComponent(accountId)}`,
+      partner_intelligence_summary_ref: "/v1/partner-intelligence/summary"
+    }
+  };
+}
+
+function buildCapabilityRegistryPackage(state, input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
+  const summary = buildCapabilityRegistrySummary();
+  const bundle = buildCapabilityRegistryBundle();
+  const classification = buildCapabilityRegistryClassificationSummary();
+  const lineage = buildCapabilityRegistryLineageSummary();
+  const operatorBundle = buildCapabilityRegistryOperatorBundle(state, { account_id: accountId });
+  const policyPack = buildCapabilityRegistryPolicyPack(state, { account_id: accountId });
+  const policyApplicationSummary = buildCapabilityRegistryPolicyApplicationSummary(state, { account_id: accountId });
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-capability-registry-package",
+    package_version: "xytara-capability-registry-package-v1",
+    account_id: accountId,
+    package_posture: {
+      registry_state: summary.registry_state,
+      catalog_state: summary.registry_posture.catalog_state,
+      adapter_state: summary.registry_posture.adapter_state,
+      recommended_registry_motion: operatorBundle.operator_posture.recommended_registry_motion,
+      recommended_policy_motion: policyPack.recommended_policy_motion
+    },
+    capability_registry_summary: summary,
+    capability_registry_bundle: bundle,
+    capability_registry_classification_summary: classification,
+    capability_registry_lineage_summary: lineage,
+    capability_registry_operator_bundle: operatorBundle,
+    capability_registry_policy_pack: policyPack,
+    capability_registry_policy_application_summary: policyApplicationSummary,
+    linked_surfaces: {
+      capability_registry_ref: "/v1/capability-registry",
+      capability_registry_summary_ref: "/v1/capability-registry/summary",
+      capability_registry_operator_bundle_ref: `/v1/capability-registry/operator-bundle?account_id=${encodeURIComponent(accountId)}`,
+      capability_registry_policy_pack_ref: `/v1/capability-registry/policy-pack?account_id=${encodeURIComponent(accountId)}`,
+      capability_registry_policy_application_summary_ref: `/v1/capability-registry/policy-application-summary?account_id=${encodeURIComponent(accountId)}`
+    }
+  };
+}
+
+function summarizeCapabilityRegistryPackage(state, input) {
+  const pack = buildCapabilityRegistryPackage(state, input);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    package_version: pack.package_version,
+    account_id: pack.account_id,
+    registry_state: pack.package_posture.registry_state,
+    recommended_registry_motion: pack.package_posture.recommended_registry_motion,
+    recommended_policy_motion: pack.package_posture.recommended_policy_motion
+  };
+}
+
+function summarizeCapabilityRegistryOperatorBundle(state, input) {
+  const bundle = buildCapabilityRegistryOperatorBundle(state, input);
+  return {
+    ok: true,
+    product: bundle.product,
+    category: bundle.category,
+    bundle_version: bundle.bundle_version,
+    account_id: bundle.account_id,
+    registry_state: bundle.operator_posture.registry_state,
+    partner_readiness_state: bundle.operator_posture.partner_readiness_state,
+    recommended_registry_motion: bundle.operator_posture.recommended_registry_motion
+  };
+}
+
+module.exports = {
+  buildCapabilityRegistrySummary,
+  buildCapabilityRegistryBundle,
+  buildCapabilityRegistryClassificationSummary,
+  buildCapabilityRegistryLineageSummary,
+  buildCapabilityRegistryOperatorBundle,
+  buildCapabilityRegistryPolicyPack,
+  summarizeCapabilityRegistryPolicyPack,
+  buildCapabilityRegistryPolicyApplicationSummary,
+  buildCapabilityRegistryPackage,
+  summarizeCapabilityRegistryPackage,
+  summarizeCapabilityRegistryOperatorBundle
+};

package/lib/command_flow.js

@@ -6,7 +6,7 @@ const {
   hydrateQuoteStates
 } = require("./commerce_runtime");
 const { consumeAccountCredits, buildUsageMeterPreview } = require("./commerce_economics");
-const { resolveSpendCredential } = require("./account_auth");
+const { resolveSpendCredential, evaluateAuthorityBindingAction } = require("./account_auth");
 const { validateIntegrationSelection } = require("../integrations/dispatch");
 const { markPaymentAccepted, verifyPaymentAcceptance } = require("./payment_verification");
 
@@ -77,6 +77,25 @@ function executeCommandRequest(state, payload, headers, options) {
         quoted_units: Number.isFinite(Number(payload.quoted_units)) ? Number(payload.quoted_units) : undefined
       });
       const requiredUnits = meteringPreview.usage_units;
+      if (delegatedSpend.ok && delegatedSpend.binding) {
+        const authorityDecision = evaluateAuthorityBindingAction(delegatedSpend.binding, "delegated_credit_spend", requiredUnits);
+        if (!authorityDecision.ok) {
+          return {
+            status: 403,
+            payload: {
+              ok: false,
+              reason: authorityDecision.reason,
+              binding_id: authorityDecision.binding_id || null,
+              required_scope: authorityDecision.required_scope || null,
+              authority_scope: authorityDecision.authority_scope || [],
+              required_consequence_family: authorityDecision.required_consequence_family || null,
+              allowed_consequence_families: authorityDecision.allowed_consequence_families || [],
+              max_units: authorityDecision.max_units || null,
+              attempted_units: authorityDecision.attempted_units || requiredUnits
+            }
+          };
+        }
+      }
       const creditSpend = consumeAccountCredits(state, {
         account_id: quote.account_id,
         agent_id: payload.agent_id || null,