xytara 1.2.0 → 1.3.0

package/README.md

@@ -30,7 +30,7 @@ The public product loop is:
 
 The package and service surfaces both follow that model.
 
-The current built-in catalog now covers a broader first-party `1.2.0` kernel than the original narrow seed, including:
+The current built-in catalog now covers a broader first-party `1.3.0` kernel than the original narrow seed, including:
 
 - trust and receipt validation/handoff tasks
 - runtime consequence tasks

package/index.js

@@ -30,11 +30,13 @@ const {
   summarizeIntegrationSubmissionBundleReview,
   summarizeIntegrationSubmissionBundleSetReview,
   summarizeIntegrationRegistrySnapshotReview,
-  summarizeIntegrationPromotionReadiness
+  summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList
 } = require("./integrations/registry");
 
 const COMMERCE_SDK_NAME = "xytara";
-const COMMERCE_SDK_VERSION = "1.2.0";
+const COMMERCE_SDK_VERSION = "1.3.0";
 const COMMERCE_API_VERSION = "v1";
 
 function createClient(options) {
@@ -73,5 +75,7 @@ module.exports = {
   summarizeIntegrationSubmissionBundleSetReview,
   summarizeIntegrationRegistrySnapshotReview,
   summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
   validateAdapterImplementation
 };

package/integrations/registry.js

@@ -452,6 +452,31 @@ function summarizeCounts(values, fieldName) {
   }));
 }
 
+function summarizeStructuredCounts(entries, fields = []) {
+  const rows = Array.isArray(entries) ? entries.filter((entry) => entry && typeof entry === "object") : [];
+  const normalizedFields = Array.isArray(fields) ? fields.filter(Boolean) : [];
+  const seen = new Map();
+
+  rows.forEach((entry) => {
+    const key = normalizedFields.map((field) => String(entry[field] || "")).join("::");
+    if (!seen.has(key)) {
+      const item = {};
+      normalizedFields.forEach((field) => {
+        item[field] = entry[field] || null;
+      });
+      item.count = 0;
+      seen.set(key, item);
+    }
+    seen.get(key).count += 1;
+  });
+
+  return Array.from(seen.values()).sort((left, right) => {
+    const leftKey = normalizedFields.map((field) => String(left[field] || "")).join("::");
+    const rightKey = normalizedFields.map((field) => String(right[field] || "")).join("::");
+    return leftKey.localeCompare(rightKey);
+  });
+}
+
 function buildPromotionReadinessSummary(input = {}) {
   const registration = input.registration && typeof input.registration === "object" ? input.registration : {};
   const certification = input.certification && typeof input.certification === "object" ? input.certification : {};
@@ -503,6 +528,204 @@ function buildPromotionReadinessSummary(input = {}) {
   };
 }
 
+function summarizePromotionBlockerCategories(blockers = []) {
+  const values = Array.isArray(blockers) ? blockers : [];
+  const categories = [];
+  if (values.some((entry) => entry === "registration_state_missing")) {
+    categories.push({
+      category: "registration",
+      severity: "high",
+      owner: "integration_author"
+    });
+  }
+  if (values.some((entry) => entry === "certification_state_missing" || entry === "not_certified")) {
+    categories.push({
+      category: "certification",
+      severity: "high",
+      owner: "review_operator"
+    });
+  }
+  if (values.some((entry) => entry === "integration_maturity_missing" || entry === "not_marked_production_default")) {
+    categories.push({
+      category: "maturity",
+      severity: "medium",
+      owner: "review_operator"
+    });
+  }
+  if (values.some((entry) => entry === "default_selection_disabled" || entry === "still_requires_explicit_selection")) {
+    categories.push({
+      category: "selection",
+      severity: "medium",
+      owner: "platform_operator"
+    });
+  }
+  if (values.some((entry) => entry === "not_bundled_for_default_rollout")) {
+    categories.push({
+      category: "rollout",
+      severity: "low",
+      owner: "release_operator"
+    });
+  }
+  return summarizeStructuredCounts(categories, ["category", "severity", "owner"]);
+}
+
+function buildCertificationGapSummary(readiness = {}, integration = {}) {
+  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
+  const certificationScope = Array.isArray(integration.certification_scope) ? integration.certification_scope.filter(Boolean) : [];
+  const verifiedWith = integration.registration && Array.isArray(integration.registration.verified_with)
+    ? integration.registration.verified_with.filter(Boolean)
+    : [];
+  const missingRequirements = [];
+  const productionReady = readiness.production_default_ready === true;
+
+  if (blockers.includes("certification_state_missing") || blockers.includes("not_certified")) {
+    missingRequirements.push("certification_state");
+  }
+  if (!productionReady && certificationScope.length < 1) {
+    missingRequirements.push("certification_scope");
+  }
+  if (!productionReady && verifiedWith.length < 1) {
+    missingRequirements.push("verified_with");
+  }
+
+  return {
+    certification_state: readiness.certification_state || null,
+    certification_scope_count: certificationScope.length,
+    verified_with_count: verifiedWith.length,
+    missing_requirements: missingRequirements,
+    certifiable: missingRequirements.length === 0
+  };
+}
+
+function buildNextTransitionSummary(readiness = {}) {
+  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
+  if (readiness.production_default_ready === true) {
+    return {
+      action: "maintain_production_default",
+      reason: "integration already satisfies production-default posture",
+      requirements: [],
+      later_actions: []
+    };
+  }
+  if (blockers.includes("registration_state_missing")) {
+    return {
+      action: "register_integration",
+      reason: "integration is missing a registration state",
+      requirements: ["registration_state"],
+      later_actions: ["complete_certification", "promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("not_certified") || blockers.includes("certification_state_missing")) {
+    return {
+      action: "complete_certification",
+      reason: "integration is not yet certified",
+      requirements: ["certification_state"],
+      later_actions: ["promote_maturity", "enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("not_marked_production_default") || blockers.includes("integration_maturity_missing")) {
+    return {
+      action: "promote_maturity",
+      reason: "integration maturity is not yet aligned with production default rollout",
+      requirements: ["integration_maturity"],
+      later_actions: ["enable_default_selection", "bundle_for_default_rollout"]
+    };
+  }
+  if (blockers.includes("default_selection_disabled") || blockers.includes("still_requires_explicit_selection")) {
+    return {
+      action: "enable_default_selection",
+      reason: "integration remains explicit-selection only",
+      requirements: ["default_selection_enabled", "requires_explicit_selection=false"],
+      later_actions: blockers.includes("not_bundled_for_default_rollout") ? ["bundle_for_default_rollout"] : []
+    };
+  }
+  if (blockers.includes("not_bundled_for_default_rollout")) {
+    return {
+      action: "bundle_for_default_rollout",
+      reason: "integration is not yet bundled for production default rollout",
+      requirements: ["bundled=true"],
+      later_actions: []
+    };
+  }
+  return {
+    action: "review_manually",
+    reason: "integration posture needs operator review",
+    requirements: [],
+    later_actions: []
+  };
+}
+
+function buildPromotionRecommendationSummary(readiness = {}) {
+  const nextTransition = buildNextTransitionSummary(readiness);
+  if (readiness.production_default_ready === true) {
+    return {
+      recommendation: "eligible_for_production_default",
+      rationale: "integration is ready for production-default posture"
+    };
+  }
+  if (readiness.review_ready === true && readiness.default_eligible === false) {
+    return {
+      recommendation: "keep_staged_until_requirements_clear",
+      rationale: nextTransition.reason
+    };
+  }
+  if (readiness.review_ready === true) {
+    return {
+      recommendation: "review_for_promotion",
+      rationale: nextTransition.reason
+    };
+  }
+  return {
+    recommendation: "complete_prerequisites_first",
+    rationale: nextTransition.reason
+  };
+}
+
+function buildPromotionActionQueues(integrations = []) {
+  const rows = Array.isArray(integrations) ? integrations.filter((entry) => entry && entry.next_transition) : [];
+  const groups = new Map();
+
+  rows.forEach((entry) => {
+    const action = entry.next_transition && entry.next_transition.action
+      ? entry.next_transition.action
+      : "review_manually";
+    if (!groups.has(action)) {
+      groups.set(action, []);
+    }
+    groups.get(action).push(entry);
+  });
+
+  return Array.from(groups.keys()).sort().map((action) => {
+    const entries = groups.get(action) || [];
+    const blockerEntries = entries.flatMap((entry) => entry.blocker_categories || []);
+    return {
+      action,
+      count: entries.length,
+      recommendation_counts: summarizeCounts(
+        entries.map((entry) => entry.promotion_recommendation && entry.promotion_recommendation.recommendation).filter(Boolean),
+        "recommendation"
+      ),
+      owner_queue: summarizeCounts(
+        blockerEntries.map((entry) => entry.owner).filter(Boolean),
+        "owner"
+      ),
+      severity_queue: summarizeCounts(
+        blockerEntries.map((entry) => entry.severity).filter(Boolean),
+        "severity"
+      ),
+      integration_ids: entries.map((entry) => entry.integration_id).filter(Boolean).sort(),
+      integrations: entries.map((entry) => ({
+        integration_id: entry.integration_id,
+        display_name: entry.display_name,
+        adapter_class: entry.adapter_class,
+        recommendation: entry.promotion_recommendation && entry.promotion_recommendation.recommendation,
+        review_ready: entry.promotion_readiness && entry.promotion_readiness.review_ready === true,
+        production_default_ready: entry.promotion_readiness && entry.promotion_readiness.production_default_ready === true
+      }))
+    };
+  });
+}
+
 function buildSubmissionBundleReviewWarnings(bundle) {
   const warnings = [];
   const registrationRecord = bundle && bundle.registration_record && typeof bundle.registration_record === "object"
@@ -723,6 +946,55 @@ function summarizeIntegrationPromotionReadiness(integrationOrId) {
   };
 }
 
+function summarizeIntegrationPromotionWorkflow(integrationOrId) {
+  const summary = summarizeIntegrationPromotionReadiness(integrationOrId);
+  if (!summary.ok) {
+    return summary;
+  }
+  const readiness = clone(summary.promotion_readiness || {});
+  return {
+    ...summary,
+    certification_gaps: buildCertificationGapSummary(readiness, summary),
+    blocker_categories: summarizePromotionBlockerCategories(readiness.blockers),
+    next_transition: buildNextTransitionSummary(readiness),
+    promotion_recommendation: buildPromotionRecommendationSummary(readiness)
+  };
+}
+
+function summarizeIntegrationPromotionWorkflowList(filters = {}) {
+  const integrations = listIntegrations(filters).map((integration) => summarizeIntegrationPromotionWorkflow(integration));
+  const blockerCategoryEntries = integrations.flatMap((entry) => entry.blocker_categories || []);
+  return {
+    ok: true,
+    integration_count: integrations.length,
+    review_ready_count: integrations.filter((entry) => entry.promotion_readiness.review_ready).length,
+    production_default_ready_count: integrations.filter((entry) => entry.promotion_readiness.production_default_ready).length,
+    certifiable_count: integrations.filter((entry) => entry.certification_gaps.certifiable).length,
+    next_actions: summarizeCounts(
+      integrations.map((entry) => entry.next_transition.action).filter(Boolean),
+      "action"
+    ),
+    recommendations: summarizeCounts(
+      integrations.map((entry) => entry.promotion_recommendation.recommendation).filter(Boolean),
+      "recommendation"
+    ),
+    blocker_categories: summarizeStructuredCounts(
+      blockerCategoryEntries,
+      ["category", "severity", "owner"]
+    ),
+    owner_queue: summarizeCounts(
+      blockerCategoryEntries.map((entry) => entry.owner).filter(Boolean),
+      "owner"
+    ),
+    severity_queue: summarizeCounts(
+      blockerCategoryEntries.map((entry) => entry.severity).filter(Boolean),
+      "severity"
+    ),
+    next_action_queues: buildPromotionActionQueues(integrations),
+    integrations
+  };
+}
+
 function buildBuiltInIntegrations() {
   const httpTaskRefs = collectTaskRefsByAdapter("http");
   const mcpTaskRefs = collectTaskRefsByAdapter("mcp");
@@ -735,7 +1007,7 @@ function buildBuiltInIntegrations() {
       display_name: "Built-In HTTP Execution",
       description: "Default execution path for task and workflow lanes served directly by xytara.",
       adapter_class: "execution_adapter",
-      adapter_version: "1.2.0",
+      adapter_version: "1.3.0",
       interface_version: "commerce-adapter-interface/v1",
       bundled: true,
       source: "builtin",
@@ -798,7 +1070,7 @@ function buildBuiltInIntegrations() {
       display_name: "Built-In MCP Protocol Lane",
       description: "Built-in machine protocol lane for MCP tool discovery and invocation through the commerce flow.",
       adapter_class: "agent_protocol_adapter",
-      adapter_version: "1.2.0",
+      adapter_version: "1.3.0",
       interface_version: "commerce-adapter-interface/v1",
       bundled: true,
       source: "builtin",
@@ -857,7 +1129,7 @@ function buildBuiltInIntegrations() {
       display_name: "Built-In x402 Payment Admission",
       description: "Built-in exact-payment challenge lane for x402-style machine payment admission.",
       adapter_class: "payment_rail_adapter",
-      adapter_version: "1.2.0",
+      adapter_version: "1.3.0",
       interface_version: "commerce-adapter-interface/v1",
       bundled: true,
       source: "builtin",
@@ -916,7 +1188,7 @@ function buildBuiltInIntegrations() {
       display_name: "Built-In Chain Settlement",
       description: "Built-in settlement lane spanning the canonical chain-backed settlement profiles bundled in xytara.",
       adapter_class: "settlement_adapter",
-      adapter_version: "1.2.0",
+      adapter_version: "1.3.0",
       interface_version: "commerce-adapter-interface/v1",
       bundled: true,
       source: "builtin",
@@ -979,7 +1251,7 @@ function buildBuiltInIntegrations() {
       display_name: "Built-In Registry Identity Surface",
       description: "Built-in registry and anchoring surface used by trust, registry, and lifecycle records.",
       adapter_class: "identity_registry_adapter",
-      adapter_version: "1.2.0",
+      adapter_version: "1.3.0",
       interface_version: "commerce-adapter-interface/v1",
       bundled: true,
       source: "builtin",
@@ -1323,6 +1595,14 @@ function summarizeIntegrationSettlementModes(filters = {}) {
   };
 }
 
+// 1.3.0 Phase 1 anchor:
+// The next workflow layer should stay read-only and build on top of
+// summarizeIntegrationPromotionReadiness(...), adding:
+// - promotion recommendation summaries
+// - next eligible transition summaries
+// - normalized blocker categories
+// without introducing mutation flows or persistent registry state.
+
 module.exports = {
   getIntegration,
   listIntegrations,
@@ -1349,6 +1629,8 @@ module.exports = {
   summarizeIntegrationSubmissionBundleSetReview,
   summarizeIntegrationRegistrySnapshotReview,
   summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
   createRegisteredIntegrationFromManifest,
   buildIntegrationRegistrationView,
   buildIntegrationView

package/package.json

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

package/server.js

@@ -53,6 +53,8 @@ const {
   getIntegration,
   listIntegrations,
   summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
   summarizeIntegrationRegistrySnapshotReview,
   summarizeIntegrationSubmissionBundleReview,
   summarizeIntegrationSubmissionBundleSetReview,
@@ -340,6 +342,24 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/v1/integrations/promotion-workflow") {
+    const response = buildIntegrationListResponse({
+      ...summarizeIntegrationPromotionWorkflowList({
+        adapter_class: url.searchParams.get("class"),
+        protocol: url.searchParams.get("protocol"),
+        settlement_mode: url.searchParams.get("settlement_mode"),
+        capability: url.searchParams.get("capability"),
+        task_ref: url.searchParams.get("task_ref"),
+        source: url.searchParams.get("source"),
+        certification_state: url.searchParams.get("certification_state"),
+        integration_maturity: url.searchParams.get("integration_maturity"),
+        bundled: url.searchParams.get("bundled")
+      })
+    });
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
   if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/") && url.pathname.endsWith("/promotion-readiness")) {
     const integrationId = getDecodedSuffixId(
       url.pathname.slice(0, -"/promotion-readiness".length),
@@ -352,6 +372,18 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/") && url.pathname.endsWith("/promotion-workflow")) {
+    const integrationId = getDecodedSuffixId(
+      url.pathname.slice(0, -"/promotion-workflow".length),
+      "/v1/integrations/"
+    );
+    const response = buildIntegrationListResponse(
+      summarizeIntegrationPromotionWorkflow(integrationId)
+    );
+    sendJson(res, response.status || 200, response.payload || response);
+    return;
+  }
+
   if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/")) {
     const integrationId = getDecodedSuffixId(url.pathname, "/v1/integrations/");
     const response = buildIntegrationDetailResponse(getIntegration(integrationId));