create-t2k 0.3.0 → 0.4.0

package/README.md

@@ -2,6 +2,7 @@
 
 Create a runnable local T2K project with a synthetic ontology, accepted facts,
 a Decision Context, two executable policies, and disjoint replay evidence.
+The existing decision-loop project remains the default profile.
 
 ```bash
 npx create-t2k@latest my-decision-loop
@@ -57,4 +58,36 @@ npx create-t2k@latest my-decision-loop --no-install
 The command refuses to write into a non-empty directory. Node.js 20.10 or newer
 is required.
 
+## Integration-hub profile
+
+Generate a focused, fully synthetic source-integration project explicitly:
+
+```bash
+npx create-t2k@latest my-integration-hub --profile integration-hub
+cd my-integration-hub
+npm start
+```
+
+This profile maps two independent registry records into one canonical party
+identity, preserves conflicting name evidence, and applies a versioned authority
+order to a conflicting registry state. It runs reconciliation again with the
+opposite input order and proves the proposal hash is identical.
+
+Every regular `source-records/*.json` file is discovered in canonical filename
+order, so the generated README experiments work without editing the runner:
+reverse the versioned authority priorities or add a third synthetic source with
+the same canonical key and run `npm start` again.
+
+The output is a deterministic evidence packet for human review. It preserves
+the complete source receipts and alternatives inside the hashed packet, does
+not mutate any source record, and does not promote the authority-selected
+candidate to accepted truth. Both included synthetic sources deliberately have
+an `unknown` authentication state. The unkeyed hashes demonstrate deterministic
+self-consistency only; they are not signatures, authentication, or proof that a
+source assertion is true.
+
+Supported profiles are `decision-loop` (the default) and `integration-hub`.
+An unknown or repeated `--profile` option fails before the target directory is
+created.
+
 Apache-2.0. Contributions require DCO sign-off in the public repository.

package/bin/create-t2k.mjs

@@ -18,14 +18,16 @@ Usage:
   create-t2k [directory] [options]
 
 Options:
+  --profile <name>  Generate decision-loop (default) or integration-hub
   --no-install   Generate the project without installing dependencies
   --yes          Accept non-interactive defaults
   -h, --help     Show this help
   -v, --version  Show the package version
 
 The default directory is my-t2k-project. Existing non-empty directories are
-never overwritten. Generated projects include decision and optional
-persisted-lifecycle examples.`;
+never overwritten. The decision-loop profile includes decision and optional
+persisted-lifecycle examples. The integration-hub profile maps independent
+synthetic sources into a non-mutating reconciliation proposal for human review.`;
 
 try {
   const options = parseArguments(process.argv.slice(2));
@@ -37,6 +39,7 @@ try {
     await scaffoldProject({
       targetDirectory: options.targetDirectory,
       install: options.install,
+      profile: options.profile,
       cwd: process.cwd(),
       stdout: process.stdout,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-t2k",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Create a local T2K governed-decision project in minutes.",
   "license": "Apache-2.0",
   "keywords": [
@@ -20,7 +20,7 @@
   },
   "type": "module",
   "bin": {
-    "create-t2k": "./bin/create-t2k.mjs"
+    "create-t2k": "bin/create-t2k.mjs"
   },
   "engines": {
     "node": ">=20.10.0"
@@ -29,6 +29,7 @@
     "bin",
     "src",
     "template",
+    "template-integration-hub",
     "README.md",
     "LICENSE"
   ],

package/src/scaffold.mjs

@@ -5,7 +5,27 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const templateRoot = path.join(packageRoot, "template");
+const profiles = {
+  "decision-loop": {
+    templateRoot: path.join(packageRoot, "template"),
+  },
+  "integration-hub": {
+    templateRoot: path.join(packageRoot, "template-integration-hub"),
+  },
+};
+
+export const CREATE_T2K_PROFILES = Object.freeze(Object.keys(profiles));
+
+function requireProfile(value) {
+  if (typeof value !== "string" || !Object.hasOwn(profiles, value)) {
+    throw new Error(
+      `Unsupported profile: ${String(value)}. Choose one of: ${CREATE_T2K_PROFILES.join(
+        ", "
+      )}.`
+    );
+  }
+  return value;
+}
 
 export function parseArguments(argumentsList) {
   const options = {
@@ -13,11 +33,14 @@ export function parseArguments(argumentsList) {
     install: true,
     help: false,
     version: false,
+    profile: "decision-loop",
   };
   const positionals = [];
   let parseOptions = true;
+  let profileProvided = false;
 
-  for (const argument of argumentsList) {
+  for (let index = 0; index < argumentsList.length; index += 1) {
+    const argument = argumentsList[index];
     if (parseOptions && argument === "--") {
       parseOptions = false;
     } else if (parseOptions && ["-h", "--help"].includes(argument)) {
@@ -28,6 +51,27 @@ export function parseArguments(argumentsList) {
       options.install = false;
     } else if (parseOptions && argument === "--yes") {
       // The scaffolder has no interactive choices; this keeps npx usage familiar.
+    } else if (parseOptions && argument === "--profile") {
+      if (profileProvided) {
+        throw new Error("Provide --profile at most once.");
+      }
+      const value = argumentsList[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("--profile requires a profile name.");
+      }
+      options.profile = requireProfile(value);
+      profileProvided = true;
+      index += 1;
+    } else if (parseOptions && argument.startsWith("--profile=")) {
+      if (profileProvided) {
+        throw new Error("Provide --profile at most once.");
+      }
+      const value = argument.slice("--profile=".length);
+      if (!value) {
+        throw new Error("--profile requires a profile name.");
+      }
+      options.profile = requireProfile(value);
+      profileProvided = true;
     } else if (parseOptions && argument.startsWith("-")) {
       throw new Error(`Unknown option: ${argument}`);
     } else {
@@ -136,16 +180,18 @@ function shellDisplay(value) {
 export async function scaffoldProject({
   targetDirectory,
   install = true,
+  profile = "decision-loop",
   cwd = process.cwd(),
   stdout = process.stdout,
 }) {
   if (typeof targetDirectory !== "string" || !targetDirectory.trim()) {
     throw new Error("Project directory is required.");
   }
+  const selectedProfile = requireProfile(profile);
   const targetPath = path.resolve(cwd, targetDirectory);
   const projectName = packageNameFor(targetPath);
   await ensureEmptyDirectory(targetPath);
-  await copyTemplate(templateRoot, targetPath, {
+  await copyTemplate(profiles[selectedProfile].templateRoot, targetPath, {
     "{{PROJECT_NAME}}": projectName,
   });
 
@@ -169,9 +215,24 @@ export async function scaffoldProject({
     stdout.write("  npm install\n");
   }
   stdout.write("  npm start\n\n");
-  stdout.write("The first run computes a recommendation; a human must still authorize it.\n");
-  stdout.write("Run `npm run db:up && npm run lifecycle` for the persisted closed loop.\n");
-  stdout.write("Use `npm run db:down` to stop it or `npm run db:reset` to delete its volume.\n");
+  if (selectedProfile === "integration-hub") {
+    stdout.write(
+      "The run maps two synthetic sources into a deterministic evidence proposal for human review.\n"
+    );
+    stdout.write(
+      "It does not authenticate either source, mutate source records, or promote a selected value to accepted truth.\n"
+    );
+  } else {
+    stdout.write(
+      "The first run computes a recommendation; a human must still authorize it.\n"
+    );
+    stdout.write(
+      "Run `npm run db:up && npm run lifecycle` for the persisted closed loop.\n"
+    );
+    stdout.write(
+      "Use `npm run db:down` to stop it or `npm run db:reset` to delete its volume.\n"
+    );
+  }
 
-  return { targetPath, projectName };
+  return { targetPath, projectName, profile: selectedProfile };
 }

package/template/package.json.template

@@ -15,6 +15,6 @@
     "lifecycle": "node src/lifecycle.mjs"
   },
   "dependencies": {
-    "@t2kai/core": "^0.3.0"
+    "@t2kai/core": "^0.4.0"
   }
 }

package/template-integration-hub/.gitignore.template

@@ -0,0 +1,3 @@
+node_modules/
+*.log
+.DS_Store

package/template-integration-hub/README.md.template

@@ -0,0 +1,45 @@
+# {{PROJECT_NAME}}
+
+This is a fully synthetic T2K integration-hub quickstart. It demonstrates how
+two independently governed source records can be mapped into one canonical
+identity without silently merging evidence or declaring either source true.
+
+```bash
+npm install
+npm start
+```
+
+The run performs these explicit steps:
+
+1. validate and compile `ontology-pack.json`;
+2. canonically discover and map every regular `source-records/*.json` file with
+   one versioned mapping;
+3. preserve all conflicting display-name candidates;
+4. apply `authority-policy.json` to select a registry-state candidate within
+   the proposal;
+5. repeat reconciliation in the opposite input order; and
+6. emit a deterministic evidence packet for human review.
+
+The selected registry-state value is only a candidate within a non-mutating
+proposal. No source record is changed and no value becomes accepted truth.
+Both source envelopes deliberately use `authenticationState: "unknown"`.
+Production callers must authenticate or attest sources and policies outside
+this example.
+
+Each complete source-mapping receipt is included in the evidence packet before
+the packet hash is computed. The receipt, policy, proposal, and packet hashes
+are unkeyed deterministic self-consistency checks. They are not signatures,
+authentication tokens, or proof that an assertion is true.
+
+## Explore the hub
+
+- Change a source value in `source-records/` and inspect the preserved evidence.
+- Reverse the priorities in `authority-policy.json`, rerun, and inspect the
+  changed proposed authority selection.
+- Add a third synthetic `.json` source with the same `party_key`; it is
+  discovered automatically on the next run.
+- Replace `humanCheckpoint: "always"` only after defining a real review and
+  authorization boundary in the calling system.
+
+Keep real people, credentials, customer vocabulary, and private source
+locations out of this project.

package/template-integration-hub/authority-policy.json

@@ -0,0 +1,10 @@
+{
+  "policyId": "synthetic-party-authority",
+  "policyVersion": "1.0.0",
+  "prioritiesByDomain": {
+    "registry_status": [
+      "synthetic_registry_alpha",
+      "synthetic_registry_beta"
+    ]
+  }
+}

package/template-integration-hub/ontology-pack.json

@@ -0,0 +1,143 @@
+{
+  "$schema": "https://t2k.ai/schemas/t2k-ontology-pack.v1.schema.json",
+  "manifestType": "t2k.ontology-pack",
+  "manifestVersion": "1.0",
+  "ontologyVersion": "1.0.0",
+  "ontologyId": "demo.integration-hub",
+  "label": "Synthetic Integration Hub",
+  "description": "Maps independently governed synthetic party records while preserving source evidence and human review.",
+  "packKind": "project",
+  "status": "accepted",
+  "scope": {
+    "domain": "synthetic_integration",
+    "description": "A non-production demonstration of canonical mapping and reconciliation.",
+    "jurisdictions": ["DEMO"],
+    "industries": [],
+    "businessStages": [],
+    "organizationSizes": [],
+    "exclusions": ["production data", "identity proofing", "autonomous truth promotion"]
+  },
+  "objectTypes": [
+    {
+      "id": "party",
+      "label": "Party",
+      "family": "Common party",
+      "nodeKind": "operating-entity",
+      "identity": ["party_id"],
+      "purpose": "A canonical party proposal whose values retain source-level evidence.",
+      "properties": [
+        {
+          "id": "party_id",
+          "valueType": "string",
+          "required": true,
+          "description": "Synthetic canonical identity key.",
+          "authorityDomain": "identity",
+          "temporal": false
+        },
+        {
+          "id": "display_name",
+          "valueType": "string",
+          "required": false,
+          "description": "A source-provided display-name candidate.",
+          "authorityDomain": "identity",
+          "temporal": true
+        },
+        {
+          "id": "registry_state",
+          "valueType": "string",
+          "required": false,
+          "description": "A source-provided registry-state candidate.",
+          "authorityDomain": "registry_status",
+          "temporal": true
+        }
+      ]
+    }
+  ],
+  "sourceMappings": [
+    {
+      "id": "synthetic_party_record_v1",
+      "mappingVersion": "1.0.0",
+      "sourceType": "independent_registry_record",
+      "sourceLocator": "synthetic://party-registry",
+      "sourceSchemaVersion": "party-record-v1",
+      "object": "party",
+      "fieldMappings": [
+        {
+          "sourcePath": "$.party_key",
+          "targetProperty": "party_id",
+          "required": true,
+          "normalizations": ["trim", "uppercase"],
+          "valueMap": {},
+          "authorityDomain": "identity",
+          "conflictPolicy": "require_review"
+        },
+        {
+          "sourcePath": "$.display_name",
+          "targetProperty": "display_name",
+          "required": true,
+          "normalizations": ["trim", "collapse_whitespace"],
+          "valueMap": {},
+          "authorityDomain": "identity",
+          "conflictPolicy": "preserve_all"
+        },
+        {
+          "sourcePath": "$.registry_state",
+          "targetProperty": "registry_state",
+          "required": true,
+          "normalizations": ["trim", "lowercase"],
+          "valueMap": {},
+          "authorityDomain": "registry_status",
+          "conflictPolicy": "prefer_authority"
+        }
+      ],
+      "targetIdentity": ["party_id"],
+      "idempotencyPath": "$.record_id",
+      "eventTimePath": "$.event_time",
+      "observedTimePath": "$.observed_time",
+      "authority": "source_specific",
+      "riskTier": "high",
+      "reviewStatus": "accepted",
+      "driftPolicy": "quarantine",
+      "lateArrivalPolicy": "quarantine",
+      "humanCheckpoint": "always",
+      "replayable": true
+    }
+  ],
+  "authorityModel": [
+    {
+      "domain": "identity",
+      "authority": "human_reviewed_source_evidence",
+      "status": "accepted",
+      "scope": "Identity candidates remain proposals until a human-owned process accepts them."
+    },
+    {
+      "domain": "registry_status",
+      "authority": "versioned_priority_policy",
+      "status": "accepted",
+      "scope": "Priority selects a candidate within the proposal and does not establish truth."
+    }
+  ],
+  "eventTypes": [
+    {
+      "id": "source_record_observed",
+      "source": "integration_hub",
+      "createsOrUpdates": "party",
+      "humanCheckpoint": "required"
+    }
+  ],
+  "reasoningFunctions": [
+    {
+      "id": "propose_canonical_reconciliation",
+      "input": "receipt-bound source evidence and versioned authority policy",
+      "output": "deterministic non-mutating proposal",
+      "humanCheckpoint": "required"
+    }
+  ],
+  "extensions": {
+    "dataPolicy": {
+      "syntheticOnly": true,
+      "authenticationProvided": false,
+      "truthPromotionAllowed": false
+    }
+  }
+}

package/template-integration-hub/package.json.template

@@ -0,0 +1,16 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "scripts": {
+    "start": "node src/run.mjs",
+    "check": "node src/run.mjs"
+  },
+  "dependencies": {
+    "@t2kai/core": "^0.4.0"
+  }
+}

package/template-integration-hub/source-records/registry-alpha.json

@@ -0,0 +1,24 @@
+{
+  "sourceSystem": "synthetic-registry-alpha",
+  "sourceLocator": "synthetic://registry-alpha/party/ALPHA-0042",
+  "sourceRecordKey": "ALPHA-0042",
+  "sourceSchemaVersion": "party-record-v1",
+  "eventTime": "2026-08-29T15:00:00.000Z",
+  "observedTime": "2026-08-29T15:00:05.000Z",
+  "authenticationState": "unknown",
+  "authorityRef": "synthetic_registry_alpha",
+  "dataClassification": "synthetic_demo",
+  "purposeTags": ["integration_hub_demo"],
+  "retentionPolicy": {
+    "policyId": "synthetic-demo-30d",
+    "expiresAt": "2026-09-28"
+  },
+  "payload": {
+    "record_id": "ALPHA-0042",
+    "party_key": " shared-0042 ",
+    "display_name": " Sample Services LLC ",
+    "registry_state": " ACTIVE ",
+    "event_time": "2026-08-29T15:00:00.000Z",
+    "observed_time": "2026-08-29T15:00:05.000Z"
+  }
+}

package/template-integration-hub/source-records/registry-beta.json

@@ -0,0 +1,24 @@
+{
+  "sourceSystem": "synthetic-registry-beta",
+  "sourceLocator": "synthetic://registry-beta/party/BETA-7001",
+  "sourceRecordKey": "BETA-7001",
+  "sourceSchemaVersion": "party-record-v1",
+  "eventTime": "2026-08-29T15:01:00.000Z",
+  "observedTime": "2026-08-29T15:01:08.000Z",
+  "authenticationState": "unknown",
+  "authorityRef": "synthetic_registry_beta",
+  "dataClassification": "synthetic_demo",
+  "purposeTags": ["integration_hub_demo"],
+  "retentionPolicy": {
+    "policyId": "synthetic-demo-30d",
+    "expiresAt": "2026-09-28"
+  },
+  "payload": {
+    "record_id": "BETA-7001",
+    "party_key": "SHARED-0042",
+    "display_name": "Sample Service Company",
+    "registry_state": "pending",
+    "event_time": "2026-08-29T15:01:00.000Z",
+    "observed_time": "2026-08-29T15:01:08.000Z"
+  }
+}

package/template-integration-hub/src/run.mjs

@@ -0,0 +1,231 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  executeSourceMapping,
+  reconcileCanonicalRecords,
+  validateOntologyPackManifest,
+} from "@t2kai/core";
+import {
+  compileOntologyPackSet,
+  compareCanonicalStrings,
+  semanticHash,
+} from "@t2kai/core/compiler";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+async function readJson(relativePath) {
+  return JSON.parse(await fs.readFile(path.join(root, relativePath), "utf8"));
+}
+
+async function readSourceRecords() {
+  const sourceDirectory = path.join(root, "source-records");
+  const sourceFiles = (await fs.readdir(sourceDirectory, { withFileTypes: true }))
+    .filter((entry) => entry.isFile() && path.extname(entry.name) === ".json")
+    .map((entry) => entry.name)
+    .sort(compareCanonicalStrings);
+
+  assert.ok(
+    sourceFiles.length >= 2,
+    "The integration-hub profile requires at least two source-records/*.json files."
+  );
+
+  return Promise.all(
+    sourceFiles.map((sourceFile) =>
+      readJson(path.posix.join("source-records", sourceFile))
+    )
+  );
+}
+
+const manifest = await readJson("ontology-pack.json");
+const authorityPolicy = await readJson("authority-policy.json");
+const sourceRecords = await readSourceRecords();
+const sourceSnapshot = structuredClone(sourceRecords);
+
+const validation = validateOntologyPackManifest(manifest);
+assert.equal(
+  validation.valid,
+  true,
+  `Integration-hub manifest failed validation: ${JSON.stringify(validation.errors)}`
+);
+
+const compilation = compileOntologyPackSet({
+  manifests: [manifest],
+  roots: [
+    {
+      ontologyId: manifest.ontologyId,
+      version: manifest.ontologyVersion,
+    },
+  ],
+});
+assert.equal(compilation.status, "valid", JSON.stringify(compilation.diagnostics));
+
+const mapping = manifest.sourceMappings.find(
+  (candidate) => candidate.id === "synthetic_party_record_v1"
+);
+assert.ok(mapping, "The integration-hub source mapping is missing.");
+
+const mappedResults = sourceRecords.map((sourceRecord) => {
+  const { payload, ...envelopeMetadata } = sourceRecord;
+  return executeSourceMapping({
+    mapping,
+    envelope: {
+      ...envelopeMetadata,
+      payload: structuredClone(payload),
+      contentHash: semanticHash(payload),
+    },
+  });
+});
+
+assert.ok(
+  mappedResults.every((result) => result.receipt.status === "mapped"),
+  "Every synthetic source record must map successfully."
+);
+assert.ok(
+  mappedResults.every((result) => result.receipt.humanReviewRequired),
+  "Every source receipt must retain the explicit human checkpoint."
+);
+assert.ok(
+  mappedResults.every(
+    (result) => result.receipt.authenticationState === "unknown"
+  ),
+  "The synthetic profile must not claim source authentication."
+);
+assert.equal(
+  new Set(mappedResults.map((result) => result.receipt.receiptHash)).size,
+  mappedResults.length,
+  "Each source record must produce independent receipt-bound evidence."
+);
+assert.equal(
+  new Set(
+    mappedResults.map((result) => semanticHash(result.canonicalRecord.identity))
+  ).size,
+  1,
+  "Every discovered source record must map to one shared canonical identity."
+);
+assert.ok(
+  Object.keys(mappedResults[0].canonicalRecord.identity).length > 0,
+  "The shared canonical identity must not be empty."
+);
+assert.deepEqual(sourceRecords, sourceSnapshot, "Source mapping mutated its input.");
+
+const mappedSnapshot = structuredClone(mappedResults);
+const reconciliation = reconcileCanonicalRecords({
+  results: mappedResults,
+  authorityPolicy,
+});
+const reverseOrderReconciliation = reconcileCanonicalRecords({
+  results: [...mappedResults].reverse(),
+  authorityPolicy,
+});
+assert.deepEqual(
+  mappedResults,
+  mappedSnapshot,
+  "Canonical reconciliation mutated mapped source evidence."
+);
+assert.equal(reconciliation.status, "needs_review");
+assert.equal(reconciliation.humanReviewRequired, true);
+assert.equal(reconciliation.nonMutating, true);
+assert.equal(reconciliation.alternativesPreserved, true);
+assert.equal(
+  reconciliation.proposalHash,
+  reverseOrderReconciliation.proposalHash,
+  "Reconciliation must be deterministic across source input order."
+);
+
+const preserveAllField = reconciliation.fields.find(
+  (field) =>
+    field.conflictPolicy === "preserve_all" &&
+    field.resolution === "preserve_all"
+);
+const preferAuthorityField = reconciliation.fields.find(
+  (field) =>
+    field.conflictPolicy === "prefer_authority" &&
+    field.resolution === "preferred_authority"
+);
+assert.ok(
+  preserveAllField,
+  "At least one conflicting field must exercise preserve_all reconciliation."
+);
+assert.equal(preserveAllField.selectedValue, null);
+assert.ok(preserveAllField.candidates.length >= 2);
+assert.ok(
+  preferAuthorityField,
+  "At least one conflicting field must exercise prefer_authority reconciliation."
+);
+assert.notEqual(preferAuthorityField.selectedValue, null);
+assert.ok(preferAuthorityField.candidates.length >= 2);
+
+const packetWithoutHash = {
+  profile: "integration-hub",
+  ontology: `${manifest.ontologyId}@${manifest.ontologyVersion}`,
+  resolutionHash: compilation.resolutionHash,
+  sourceEvidence: mappedResults
+    .map((result) => ({
+      summary: {
+        sourceSystem: result.receipt.sourceSystem,
+        sourceRecordKey: result.receipt.sourceRecordKey,
+        authorityRef: result.receipt.authorityRef,
+        authenticationState: result.receipt.authenticationState,
+        receiptHash: result.receipt.receiptHash,
+        humanReviewRequired: result.receipt.humanReviewRequired,
+      },
+      receipt: result.receipt,
+    }))
+    .sort((left, right) =>
+      compareCanonicalStrings(
+        left.receipt.receiptHash,
+        right.receipt.receiptHash
+      )
+    ),
+  reconciliation: {
+    proposalHash: reconciliation.proposalHash,
+    status: reconciliation.status,
+    canonicalIdentity: reconciliation.identity,
+    authorityPolicy: {
+      policyId: reconciliation.policyId,
+      policyVersion: reconciliation.policyVersion,
+      policyHash: reconciliation.policyHash,
+    },
+    deterministicAcrossInputOrder:
+      reconciliation.proposalHash === reverseOrderReconciliation.proposalHash,
+    humanReviewRequired: reconciliation.humanReviewRequired,
+    nonMutating: reconciliation.nonMutating,
+    alternativesPreserved: reconciliation.alternativesPreserved,
+    preserveAll: {
+      propertyRef: preserveAllField.propertyRef,
+      resolution: preserveAllField.resolution,
+      selectedValue: preserveAllField.selectedValue,
+      candidates: preserveAllField.candidates,
+    },
+    preferAuthority: {
+      propertyRef: preferAuthorityField.propertyRef,
+      resolution: preferAuthorityField.resolution,
+      selectedWithinProposal: preferAuthorityField.selectedValue,
+      candidates: preferAuthorityField.candidates,
+    },
+  },
+  humanReview: {
+    status: "pending_human_review",
+    proposalOnly: true,
+    issues: reconciliation.issues
+      .filter((issue) => issue.severity === "review")
+      .map(({ code, message, receiptHash }) => ({ code, message, receiptHash })),
+  },
+  boundaries: {
+    syntheticDataOnly: true,
+    sourceRecordsMutated: false,
+    sourceAuthenticationEstablished: false,
+    acceptedTruthCreated: false,
+    authoritySelectionIsProposalOnly: true,
+    externalAuthenticationAndDispositionRequired: true,
+  },
+};
+const output = {
+  ...packetWithoutHash,
+  evidencePacketHash: semanticHash(packetWithoutHash),
+};
+
+console.log(JSON.stringify(output, null, 2));