xoonya 1.2.0 → 1.4.0

package/README.md

@@ -98,6 +98,8 @@ Primary proof-model routes:
 - `GET /v1/integrations`
 - `GET /v1/integrations/summary`
 - `GET /v1/integrations/snapshot`
+- `GET /v1/integrations/promotion-readiness`
+- `GET /v1/integrations/promotion-workflow`
 
 Preserved compatibility routes:
 
@@ -160,6 +162,8 @@ The package now includes:
 - `exportIntegrationRegistrySnapshot(...)`
 - `validateIntegrationRegistrySnapshot(...)`
 - `summarizeIntegrationPromotionReadiness(...)`
+- `summarizeIntegrationPromotionWorkflow(...)`
+- `summarizeIntegrationPromotionWorkflowList(...)`
 
 Those helpers are intended to normalize proof-adjacent integrations without letting pricing, workflow, or settlement logic leak into the proof kernel.
 
@@ -172,6 +176,9 @@ For lightweight local review flows, `xoonya` also includes a small repo-local pr
 ```bash
 node scripts/registry_cli.js validate-registration --example verifier
 node scripts/registry_cli.js export-snapshot --registration_state staging_registered
+node scripts/registry_cli.js promotion-readiness --integration partner.verifier.lattice_notary
+node scripts/registry_cli.js promotion-workflow --integration partner.verifier.lattice_notary
+node scripts/registry_cli.js promotion-workflow-summary --source third_party_example --registration_state staging_registered --bundled false
 ```
 
 That tooling is intentionally narrow: validate proof-integration registration posture and export filtered proof registry snapshots.
@@ -182,3 +189,4 @@ The proof-side readiness layer now also makes promotion posture explicit without
 - default-eligible means it can participate in the proof-side default posture
 - production-default-ready means certification, maturity, bundled posture, and selection posture all line up
 - blockers are returned as data instead of being left implicit
+- promotion workflow summaries now show the next proof-side transition and the current recommendation without introducing approval state

package/integrations/registry.js

@@ -10,6 +10,13 @@ function sortStrings(values) {
   return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
 }
 
+function summarizeCounts(values, fieldName) {
+  return sortStrings(values).map((value) => ({
+    [fieldName]: value,
+    count: values.filter((entry) => entry === value).length
+  }));
+}
+
 function createIntegrationDescriptor(descriptor, extras = {}) {
   return {
     integration_id: descriptor.integration_id,
@@ -190,6 +197,129 @@ function buildProofPromotionReadinessSummary(input = {}) {
   };
 }
 
+function summarizeProofPromotionBlockerCategories(blockers = []) {
+  const values = Array.isArray(blockers) ? blockers : [];
+  const categories = [];
+  if (values.some((entry) => entry === "registration_state_missing")) categories.push("registration");
+  if (values.some((entry) => entry === "certification_state_missing" || entry === "not_certified")) categories.push("certification");
+  if (values.some((entry) => entry === "integration_maturity_missing" || entry === "not_marked_production_default")) categories.push("maturity");
+  if (values.some((entry) => entry === "default_selection_disabled" || entry === "still_requires_explicit_selection")) categories.push("selection");
+  if (values.some((entry) => entry === "not_bundled_for_default_rollout")) categories.push("rollout");
+  return summarizeCounts(categories, "category");
+}
+
+function buildProofCertificationGapSummary(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 buildProofNextTransitionSummary(readiness = {}) {
+  const blockers = Array.isArray(readiness.blockers) ? readiness.blockers : [];
+  if (readiness.production_default_ready === true) {
+    return {
+      action: "maintain_production_default",
+      reason: "integration already satisfies proof-side production-default posture",
+      requirements: [],
+      later_actions: []
+    };
+  }
+  if (blockers.includes("registration_state_missing")) {
+    return {
+      action: "register_integration",
+      reason: "proof 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: "proof 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: "proof integration maturity is not yet aligned with production-default posture",
+      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: "proof 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: "proof integration is not yet bundled for production-default rollout",
+      requirements: ["bundled=true"],
+      later_actions: []
+    };
+  }
+  return {
+    action: "review_manually",
+    reason: "proof integration posture needs review",
+    requirements: [],
+    later_actions: []
+  };
+}
+
+function buildProofPromotionRecommendationSummary(readiness = {}) {
+  const nextTransition = buildProofNextTransitionSummary(readiness);
+  if (readiness.production_default_ready === true) {
+    return {
+      recommendation: "eligible_for_production_default",
+      rationale: "proof 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 summarizeIntegrationPromotionReadiness(integrationOrId) {
   const integration = typeof integrationOrId === "string"
     ? getIntegration(integrationOrId)
@@ -217,6 +347,45 @@ 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: buildProofCertificationGapSummary(readiness, summary),
+    blocker_categories: summarizeProofPromotionBlockerCategories(readiness.blockers),
+    next_transition: buildProofNextTransitionSummary(readiness),
+    promotion_recommendation: buildProofPromotionRecommendationSummary(readiness)
+  };
+}
+
+function summarizeIntegrationPromotionWorkflowList(filters = {}) {
+  const integrations = listIntegrations(filters).map((integration) => summarizeIntegrationPromotionWorkflow(integration));
+  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: summarizeCounts(
+      integrations.flatMap((entry) => (entry.blocker_categories || []).map((item) => item.category)).filter(Boolean),
+      "category"
+    ),
+    integrations
+  };
+}
+
 const BUILTIN_INTEGRATIONS = [
   createIntegrationDescriptor({
     integration_id: "builtin.identity.legacy_material",
@@ -454,6 +623,8 @@ module.exports = {
   listIntegrations,
   summarizeIntegrations,
   summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
   validateIntegrationRegistration,
   importRegisteredIntegration,
   createIntegrationRegistrySnapshot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xoonya",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
   "type": "commonjs",

package/server.js

@@ -4,6 +4,8 @@ const proofSdk = require('./index.js');
 const {
   getIntegration,
   exportIntegrationRegistrySnapshot,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
   summarizeIntegrationPromotionReadiness,
   summarizeIntegrations
 } = require('./integrations/registry');
@@ -157,6 +159,22 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/v1/integrations/promotion-workflow') {
+    const response = buildIntegrationListResponse(summarizeIntegrationPromotionWorkflowList({
+      integration_class: url.searchParams.get('class'),
+      capability: url.searchParams.get('capability'),
+      surface: url.searchParams.get('surface'),
+      source: url.searchParams.get('source'),
+      certification_state: url.searchParams.get('certification_state'),
+      integration_maturity: url.searchParams.get('integration_maturity'),
+      registration_state: url.searchParams.get('registration_state'),
+      proof_scope: url.searchParams.get('proof_scope'),
+      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 = decodeURIComponent(
       url.pathname
@@ -168,6 +186,17 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/integrations/') && url.pathname.endsWith('/promotion-workflow')) {
+    const integrationId = decodeURIComponent(
+      url.pathname
+        .slice('/v1/integrations/'.length, -'/promotion-workflow'.length)
+        .replace(/\/$/, '')
+    );
+    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 = decodeURIComponent(url.pathname.slice('/v1/integrations/'.length));
     const response = buildIntegrationDetailResponse(getIntegration(integrationId));