xoonya 1.27.0 → 2.1.0

package/FINAL_CONTRACT.md

@@ -17,13 +17,13 @@ It exists to make machine-action evidence:
 
 ## Public Release Stance
 
-This product is being prepared as a first public release from private lineage.
+This product is being prepared as a first public release.
 
 That means:
 
-- prior internal proof formats are design history, not public obligations
-- useful lineage may be preserved where it strengthens the final product
-- historical private helper shapes do not automatically become the public contract
+- prior proof formats are design history, not public obligations
+- useful earlier decisions may be preserved where they strengthen the final product
+- older helper shapes do not automatically become the public contract
 
 The public baseline should therefore be chosen for correctness, clarity, determinism, and extensibility, not for backward compatibility with prior private repos.
 
@@ -409,7 +409,7 @@ The public API of `xoonya` should center on:
 
 Optional profile helpers may be added separately.
 
-## What Should Be Carried Forward From Older Proof Lineage
+## What Should Be Carried Forward From Earlier Proof Iterations
 
 Keep:
 
@@ -422,7 +422,7 @@ Keep:
 
 Do not freeze directly:
 
-- historical internal names
+- historical implementation names
 - historical version labels
 - exact old byte-count decisions as sacred
 - old rail-shaped assumptions

package/PUBLISH_PLAN.md

@@ -0,0 +1,12 @@
+# xoonya Publish Plan
+
+1. Run `npm run verify:release-candidate`.
+2. Run `npm pack --dry-run --json` and confirm the package contents.
+3. Publish with `npm publish --access public`.
+4. Redeploy the live service surfaces.
+5. Verify:
+   - `/v1/release-candidate/summary`
+   - `/v1/release-center/summary`
+   - `/v1/announcement-pack/summary`
+   - `/v1/outreach-proof/summary`
+6. Run the first public proof-side review path.

package/README.md

@@ -37,6 +37,70 @@ The intended production-facing proof path is now:
 
 The rest of this README explains the broader route ladder, but the public starting posture should now be understandable from that one proof-side path.
 
+For a direct one-line proof-side review of a carried handoff bundle, use the bundled CLI:
+
+```bash
+xoonya-review --file ./handoff.json --summary
+```
+
+For release-grade adoption posture, inspect:
+
+- `GET /v1/release-pack`
+- `GET /v1/release-pack/summary`
+- `GET /v1/release-pack/comparison`
+- `GET /v1/release-pack/comparison/summary`
+- `GET /v1/release-pack/adoption`
+- `GET /v1/release-pack/adoption/summary`
+- `GET /v1/release-pack/scenarios`
+- `GET /v1/release-pack/scenarios/summary`
+- `GET /v1/release-pack/launch`
+- `GET /v1/release-pack/launch/summary`
+- `GET /v1/release-manifest`
+- `GET /v1/release-manifest/summary`
+- `GET /v1/release-notes`
+- `GET /v1/release-notes/summary`
+- `GET /v1/release-center`
+- `GET /v1/release-center/summary`
+- `GET /v1/release-history`
+- `GET /v1/release-history/summary`
+- `GET /v1/publish-plan`
+- `GET /v1/publish-plan/summary`
+- `GET /v1/ecosystem-entry`
+- `GET /v1/ecosystem-entry/summary`
+- `GET /v1/launch-narrative`
+- `GET /v1/launch-narrative/summary`
+- `GET /v1/outreach-proof`
+- `GET /v1/outreach-proof/summary`
+- `GET /v1/announcement-pack`
+- `GET /v1/announcement-pack/summary`
+- `GET /v1/release-candidate`
+- `GET /v1/release-candidate/summary`
+- `xoonya-release --summary`
+- `xoonya-release --comparison --summary`
+- `xoonya-release --adoption --summary`
+- `xoonya-release --scenarios --summary`
+- `xoonya-release --launch --summary`
+- `xoonya-release --manifest --summary`
+- `xoonya-release --notes --summary`
+- `xoonya-release --center --summary`
+- `xoonya-release --history --summary`
+- `xoonya-release --ecosystem --summary`
+- `xoonya-release --narrative --summary`
+- `xoonya-release --outreach-proof --summary`
+- `xoonya-release --announcement --summary`
+- `xoonya-release --candidate --summary`
+
+These surfaces package the current proof-side value story, first-contact proof-review CLI path, proof-center posture, handoff/review/governance surfaces, and integration breadth into one machine-readable launch boundary.
+
+For explicit runtime-economics carry, the proof-side handoff boundary now also accepts a canonical `handoff_bundle` wrapper from `xytara` so the economic consequence seam stays contract-shaped across the two repos instead of being reassembled ad hoc by callers.
+
+That same carried bundle can now also ride inside the normal result-package handoff path:
+
+- if `xytara` sends `handoff_bundle.economic_consequence_handoff_bundle`
+- `xoonya` will validate it through the existing bounded handoff logic
+- normal result-package review and run surfaces will expose compact economic-conformance review data automatically
+- direct-pay or non-metered handoffs remain unaffected
+
 The package and service now also expose a default proof center surface so the intended proof-native path is easy to inspect directly:
 
 - canonical event bundle v1
@@ -118,6 +182,7 @@ The package quickstart demonstrates:
 - proof bundle construction
 - proof bundle verification
 - transaction proof-handoff follow-through
+- proof-side bridge carry for explicit economic consequence review when runtime economics need proof-adjacent preservation
 
 ## Service Quickstart
 
@@ -179,6 +244,8 @@ Primary proof-model routes:
 - `POST /v1/proof-center/bridge/receipt-wrap`
 - `POST /v1/proof-center/bridge/validator-verify`
 - `POST /v1/proof-center/bridge/receipt-ledger-handoff`
+- `POST /v1/proof-center/bridge/economic-handoff`
+- `POST /v1/proof-center/bridge/economic-conformance-pack`
 - `POST /v1/proof-center/bridge/operator-review-pack`
 - `POST /v1/proof-center/bridge/compatibility-pack`
 - `POST /v1/proof-center/bridge/workflow-pack`
@@ -217,6 +284,8 @@ Primary proof-model routes:
 - `POST /v1/proof-center/result-package-handoff/review/operating-interface-run`
 - `POST /v1/proof-center/result-package-handoff/review/operating-integration`
 - `POST /v1/proof-center/result-package-handoff/review/operating-integration-carry`
+
+When `xytara` sends `handoff_bundle.economic_consequence_handoff_bundle`, `xoonya` now preserves a compact `economic_audit_summary` inside review output so proof-side operators can see the linked `account_ref`, `usage_meter_ref`, `credit_spend_ref`, `usage_units`, `pricing_band`, `payment_ref`, `settlement_ref`, `settlement_txid`, `settlement_finality_status`, `treasury_receipt_ref`, `proof_ref`, and `conformance_pack_ref` without re-deriving the carry by hand.
 - `POST /v1/proof-center/result-package-handoff/review/operating-integration-run`
 - `POST /v1/proof-center/result-package-handoff/review/operating-path`
 - `POST /v1/proof-center/result-package-handoff/review/operating-path-carry`

package/RELEASE_CHECKLIST.md

@@ -0,0 +1,10 @@
+# xoonya Release Checklist
+
+1. Run `npm run verify:release-candidate`.
+2. Confirm `npm pack --dry-run --json` includes the public docs and both CLI entrypoints.
+3. Redeploy the service and verify:
+   - `/v1/release-center/summary`
+   - `/v1/announcement-pack/summary`
+   - `/v1/outreach-proof/summary`
+4. Run the first public proof-side review path.
+5. Only then publish the npm package.

package/RELEASE_NOTES.md

@@ -0,0 +1,19 @@
+# xoonya 2.1.0 Release Notes
+
+`xoonya` 2.1.0 is the public proof-spine release-candidate line.
+
+Highlights:
+
+- direct one-line proof-side review with `xoonya-review`
+- release, comparison, adoption, scenario, and launch packs over HTTP and CLI
+- release-center, announcement-pack, and release-candidate surfaces for public launch readiness
+- canonical event, receipt, and proof-bundle model
+- bridge and governance surfaces for reviewable proof posture
+- stable runtime-to-proof followthrough
+
+Recommended first checks:
+
+1. `npm install xoonya`
+2. `xoonya-release --candidate --summary`
+3. `npm run verify:release-candidate`
+4. inspect `/v1/release-candidate/summary` on the deployed service

package/SERVICE_CONTRACT.md

@@ -33,6 +33,8 @@ Primary proof-model routes:
 - `POST /v1/proof-center/bridge/receipt-wrap`
 - `POST /v1/proof-center/bridge/validator-verify`
 - `POST /v1/proof-center/bridge/receipt-ledger-handoff`
+- `POST /v1/proof-center/bridge/economic-handoff`
+- `POST /v1/proof-center/bridge/economic-conformance-pack`
 - `POST /v1/proof-center/bridge/operator-review-pack`
 - `POST /v1/proof-center/bridge/compatibility-pack`
 - `POST /v1/proof-center/bridge/workflow-pack`
@@ -81,6 +83,20 @@ The constitutional proof loop for `xoonya` is:
 4. build proof bundle
 5. verify proof bundle
 
+Bridge-side economic carry should use:
+
+1. pass deterministic runtime economics through `POST /v1/proof-center/bridge/economic-handoff`
+2. prefer the canonical `handoff_bundle` wrapper emitted by `xytara`
+3. review the preserved usage-meter and credit-spend consequence through `POST /v1/proof-center/bridge/economic-conformance-pack`
+4. keep proof itself minimal while preserving the economic handoff as a bounded bridge/export surface
+
+Normal result-package handoff should also accept carried economics when present:
+
+1. send the normal result-package `handoff_bundle`
+2. include `handoff_bundle.economic_consequence_handoff_bundle` when the transaction-side path was credit-backed and metered
+3. expect `POST /v1/proof-center/result-package-handoff/run` and review-summary surfaces to expose compact economic-conformance review data automatically
+4. omit that bundle entirely on direct-pay or non-metered paths without changing proof intake behavior
+
 This loop is exercised through:
 
 - package verification

package/bin/xoonya-release.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+"use strict";
+
+const {
+  buildReleasePack,
+  summarizeReleasePack,
+  buildComparisonPack,
+  summarizeComparisonPack,
+  buildAdoptionPack,
+  summarizeAdoptionPack,
+  buildScenarioPack,
+  summarizeScenarioPack,
+  buildLaunchPack,
+  summarizeLaunchPack
+} = require("../lib/release_pack");
+const {
+  buildReleaseManifest,
+  summarizeReleaseManifest,
+  buildLaunchNotes,
+  summarizeLaunchNotes
+} = require("../lib/release_manifest");
+const {
+  buildReleaseCenter,
+  summarizeReleaseCenter
+} = require("../lib/release_center");
+const {
+  buildReleaseHistory,
+  summarizeReleaseHistory
+} = require("../lib/release_history");
+const {
+  buildPublishPlan,
+  summarizePublishPlan
+} = require("../lib/publish_plan");
+const {
+  buildEcosystemEntryPack,
+  summarizeEcosystemEntryPack
+} = require("../lib/ecosystem_entry");
+const {
+  buildLaunchNarrativePack,
+  summarizeLaunchNarrativePack
+} = require("../lib/launch_narrative");
+const {
+  buildOutreachProofPack,
+  summarizeOutreachProofPack
+} = require("../lib/outreach_proof");
+const {
+  buildAnnouncementPack,
+  summarizeAnnouncementPack
+} = require("../lib/announcement_pack");
+const {
+  buildReleaseCandidatePack,
+  summarizeReleaseCandidatePack
+} = require("../lib/release_candidate");
+
+function printUsage() {
+  process.stderr.write(
+    [
+      "Usage:",
+      "  xoonya-release [--summary] [--comparison] [--adoption] [--scenarios] [--launch] [--manifest] [--notes] [--center] [--history] [--publish-plan] [--ecosystem] [--narrative] [--outreach-proof] [--announcement] [--candidate] [--pretty]",
+      "",
+      "Options:",
+      "  --summary   Emit the compact release-pack summary",
+      "  --comparison   Emit the launch comparison pack",
+      "  --adoption   Emit the machine-world adoption pack",
+      "  --scenarios   Emit the first-run scenario pack",
+      "  --launch   Emit the compact launch/operator pack",
+      "  --manifest   Emit the release manifest",
+      "  --notes   Emit the release notes artifact",
+      "  --center   Emit the canonical release center artifact",
+      "  --history   Emit the release history artifact",
+      "  --publish-plan   Emit the publish-day command artifact",
+      "  --ecosystem   Emit the ecosystem entry artifact",
+      "  --narrative   Emit the launch narrative artifact",
+      "  --outreach-proof   Emit the outreach proof artifact",
+      "  --announcement   Emit the announcement artifact",
+      "  --candidate   Emit the release candidate artifact",
+      "  --pretty    Pretty-print JSON output"
+    ].join("\n")
+  );
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    process.stderr.write("\n");
+    process.exit(0);
+  }
+
+  const summary = args.includes("--summary");
+  const comparison = args.includes("--comparison");
+  const adoption = args.includes("--adoption");
+  const scenarios = args.includes("--scenarios");
+  const launch = args.includes("--launch");
+  const manifest = args.includes("--manifest");
+  const notes = args.includes("--notes");
+  const center = args.includes("--center");
+  const history = args.includes("--history");
+  const publishPlan = args.includes("--publish-plan");
+  const ecosystem = args.includes("--ecosystem");
+  const narrative = args.includes("--narrative");
+  const outreachProof = args.includes("--outreach-proof");
+  const announcement = args.includes("--announcement");
+  const candidate = args.includes("--candidate");
+  const pretty = args.includes("--pretty") || summary;
+  let payload;
+  if (comparison && summary) {
+    payload = summarizeComparisonPack();
+  } else if (comparison) {
+    payload = buildComparisonPack();
+  } else if (adoption && summary) {
+    payload = summarizeAdoptionPack();
+  } else if (adoption) {
+    payload = buildAdoptionPack();
+  } else if (scenarios && summary) {
+    payload = summarizeScenarioPack();
+  } else if (scenarios) {
+    payload = buildScenarioPack();
+  } else if (launch && summary) {
+    payload = summarizeLaunchPack();
+  } else if (launch) {
+    payload = buildLaunchPack();
+  } else if (manifest && summary) {
+    payload = summarizeReleaseManifest();
+  } else if (manifest) {
+    payload = buildReleaseManifest();
+  } else if (notes && summary) {
+    payload = summarizeLaunchNotes();
+  } else if (notes) {
+    payload = buildLaunchNotes();
+  } else if (center && summary) {
+    payload = summarizeReleaseCenter();
+  } else if (center) {
+    payload = buildReleaseCenter();
+  } else if (history && summary) {
+    payload = summarizeReleaseHistory();
+  } else if (history) {
+    payload = buildReleaseHistory();
+  } else if (publishPlan && summary) {
+    payload = summarizePublishPlan();
+  } else if (publishPlan) {
+    payload = buildPublishPlan();
+  } else if (ecosystem && summary) {
+    payload = summarizeEcosystemEntryPack();
+  } else if (ecosystem) {
+    payload = buildEcosystemEntryPack();
+  } else if (narrative && summary) {
+    payload = summarizeLaunchNarrativePack();
+  } else if (narrative) {
+    payload = buildLaunchNarrativePack();
+  } else if (outreachProof && summary) {
+    payload = summarizeOutreachProofPack();
+  } else if (outreachProof) {
+    payload = buildOutreachProofPack();
+  } else if (announcement && summary) {
+    payload = summarizeAnnouncementPack();
+  } else if (announcement) {
+    payload = buildAnnouncementPack();
+  } else if (candidate && summary) {
+    payload = summarizeReleaseCandidatePack();
+  } else if (candidate) {
+    payload = buildReleaseCandidatePack();
+  } else {
+    payload = summary ? summarizeReleasePack() : buildReleasePack();
+  }
+  process.stdout.write(JSON.stringify(payload, null, pretty ? 2 : 0));
+}
+
+main();

package/bin/xoonya-review.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const sdk = require("../index.js");
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function printUsage() {
+  process.stdout.write([
+    "Usage: xoonya-review (--file <handoff.json> | --json <json>) [--summary] [--pretty]",
+    "",
+    "Options:",
+    "  --file <path>   Read the handoff payload from a JSON file",
+    "  --json <json>   Read the handoff payload from an inline JSON string",
+    "  --summary       Return the compact review summary instead of full review",
+    "  --pretty        Pretty-print JSON output",
+    "  --help          Show this help message"
+  ].join("\n"));
+}
+
+function loadInput(args) {
+  if (args.file) {
+    return JSON.parse(fs.readFileSync(path.resolve(process.cwd(), args.file), "utf8"));
+  }
+  if (args.json) {
+    return JSON.parse(args.json);
+  }
+  throw new Error("file_or_json_required");
+}
+
+function writeOutput(payload, pretty) {
+  process.stdout.write(JSON.stringify(payload, null, pretty ? 2 : 0));
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printUsage();
+    return;
+  }
+  const input = loadInput(args);
+  const payload = args.summary === true
+    ? sdk.summarizeReviewedInteractionResultPackageHandoff(input)
+    : sdk.reviewInteractionResultPackageHandoff(input);
+  writeOutput(payload, args.pretty === true);
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/index.js

@@ -2,5 +2,15 @@
 
 module.exports = {
   ...require("./proof_sdk"),
-  ...require("./integrations/registry")
+  ...require("./integrations/registry"),
+  ...require("./lib/release_pack"),
+  ...require("./lib/release_manifest"),
+  ...require("./lib/release_center"),
+  ...require("./lib/release_history"),
+  ...require("./lib/publish_plan"),
+  ...require("./lib/ecosystem_entry"),
+  ...require("./lib/launch_narrative"),
+  ...require("./lib/outreach_proof"),
+  ...require("./lib/announcement_pack"),
+  ...require("./lib/release_candidate")
 };

package/lib/announcement_pack.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAnnouncementPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-announcement-pack",
+    public_quickstart: {
+      install: "npm install xoonya",
+      first_cli: "xoonya-review --file ./handoff.json --summary",
+      first_release_view: "xoonya-release --center --summary",
+      first_http: "/v1/release-center/summary"
+    },
+    release_candidate: {
+      checks: [
+        "install the package on a clean machine",
+        "run xoonya-release --center --summary",
+        "run npm run verify:all",
+        "verify /v1/release-center/summary on the deployed service",
+        "verify /v1/outreach-proof/summary on the deployed service"
+      ]
+    },
+    publish_day: {
+      sequence: [
+        "publish the npm package",
+        "redeploy the service and docs surfaces",
+        "verify release-center, launch-narrative, and outreach-proof summaries live",
+        "run the first public proof-side review path",
+        "share the announcement artifact with proof operators and verification-focused builders"
+      ]
+    },
+    public_message: {
+      headline: "reviewable proof continuation for machine actions that cross trust boundaries",
+      who_should_try_first: [
+        "proof operators",
+        "runtime builders needing verification followthrough",
+        "governance and audit teams"
+      ]
+    }
+  };
+}
+
+function summarizeAnnouncementPack() {
+  const pack = buildAnnouncementPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    rc_check_count: pack.release_candidate.checks.length,
+    publish_step_count: pack.publish_day.sequence.length,
+    first_cli: pack.public_quickstart.first_cli,
+    audience_count: pack.public_message.who_should_try_first.length
+  };
+}
+
+module.exports = {
+  buildAnnouncementPack,
+  summarizeAnnouncementPack
+};

package/lib/ecosystem_entry.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildEcosystemEntryPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-ecosystem-entry",
+    audiences: [
+      {
+        audience_ref: "proof_operator",
+        why_now: "needs a direct first review path for carried runtime handoff bundles",
+        first_path_ref: "scenario.carried_handoff.review",
+        first_http_entrypoint: "/v1/proof-center/result-package-handoff/review/summary",
+        first_cli_entrypoint: "xoonya-review --file ./handoff.json --summary"
+      },
+      {
+        audience_ref: "runtime_builder_needing_verification",
+        why_now: "needs a stable proof continuation after runtime output crosses trust boundaries",
+        first_path_ref: "scenario.result_package.followthrough",
+        first_http_entrypoint: "/v1/proof-center/result-package-handoff/review/summary",
+        first_cli_entrypoint: "xoonya-release --scenarios --summary"
+      },
+      {
+        audience_ref: "adapter_integrator",
+        why_now: "needs a proof contract that survives changing runtimes and settlement choices",
+        first_path_ref: "scenario.default_proof.loop",
+        first_http_entrypoint: "/v1/proof-center/default-loops/summary",
+        first_cli_entrypoint: "xoonya-release --launch --summary"
+      },
+      {
+        audience_ref: "governance_or_audit_team",
+        why_now: "needs handoff and governance posture before trusting proof-native followthrough",
+        first_path_ref: "scenario.carried_handoff.review",
+        first_http_entrypoint: "/v1/release-center/summary",
+        first_cli_entrypoint: "xoonya-release --center --summary"
+      }
+    ],
+    public_lead_sequence: [
+      "identify the proof-side audience and first success path",
+      "show the smallest review or proof loop entrypoint",
+      "show the matching comparison and adoption summary",
+      "show the release center when trust, breadth, and maturity need one compact artifact"
+    ]
+  };
+}
+
+function summarizeEcosystemEntryPack() {
+  const pack = buildEcosystemEntryPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    audience_count: pack.audiences.length,
+    first_audience: pack.audiences[0] ? pack.audiences[0].audience_ref : null,
+    lead_step_count: pack.public_lead_sequence.length
+  };
+}
+
+module.exports = {
+  buildEcosystemEntryPack,
+  summarizeEcosystemEntryPack
+};

package/lib/launch_narrative.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildLaunchNarrativePack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-launch-narrative",
+    why_now: "machine actions increasingly need reviewable evidence after they cross trust boundaries, and opaque logs or narrow receipts are not enough",
+    problem_patchwork_misses: [
+      "runtime logs do not become a stable proof contract by themselves",
+      "receipt-only systems miss reviewable carry, governance posture, and proof-native followthrough",
+      "settlement-specific proof systems do not generalize cleanly across changing runtimes and rails"
+    ],
+    strongest_public_claim: "reviewable proof continuation for machine actions that cross trust boundaries",
+    first_proof_to_run: {
+      path_ref: "scenario.carried_handoff.review",
+      why_this_first: "smallest strong-signal proof-side intake that shows carried runtime context, proof readiness, and operator review posture",
+      cli: "xoonya-review --file ./handoff.json --summary"
+    },
+    first_success_looks_like: [
+      "handoff bundle is accepted and review summary is intelligible",
+      "proof readiness is visible before proof-native continuation",
+      "economic and settlement carry survives into proof-side review",
+      "handoff and governance posture are inspectable instead of hidden"
+    ],
+    immediate_should_care: [
+      "proof operators needing carried handoff review",
+      "runtime builders needing stable verification followthrough",
+      "adapter integrators needing a durable proof contract",
+      "audit and governance teams needing reviewable machine evidence"
+    ]
+  };
+}
+
+function summarizeLaunchNarrativePack() {
+  const pack = buildLaunchNarrativePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    patchwork_gap_count: pack.problem_patchwork_misses.length,
+    success_signal_count: pack.first_success_looks_like.length,
+    immediate_audience_count: pack.immediate_should_care.length,
+    first_path_ref: pack.first_proof_to_run.path_ref
+  };
+}
+
+module.exports = {
+  buildLaunchNarrativePack,
+  summarizeLaunchNarrativePack
+};