create-t2k 0.3.0 → 0.4.1

package/README.md

@@ -2,9 +2,10 @@
 
 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
+npx create-t2k@0.4.1 my-decision-loop
 cd my-decision-loop
 npm start
 ```
@@ -30,6 +31,10 @@ Stop the local containers without deleting lifecycle data with `npm run
 db:down`. Use the explicitly destructive `npm run db:reset` only when you
 intend to delete the disposable local database volume.
 
+Compose binds PostgreSQL to `127.0.0.1:55432` only. The included `t2k` username
+and `t2k` password are disposable local-only quickstart credentials; never
+reuse them or expose this generated database to another host.
+
 To expose ontology validation, compilation, policy execution, replay, and
 reward evaluation to an MCP host, add:
 
@@ -38,7 +43,7 @@ reward evaluation to an MCP host, add:
   "mcpServers": {
     "t2k": {
       "command": "npx",
-      "args": ["-y", "@t2kai/mcp@latest"]
+      "args": ["-y", "@t2kai/mcp@0.3.0"]
     }
   }
 }
@@ -51,10 +56,55 @@ before enabling database access or agent writes.
 Use `--no-install` to generate files without running `npm install`:
 
 ```bash
-npx create-t2k@latest my-decision-loop --no-install
+npx create-t2k@0.4.1 my-decision-loop --no-install
 ```
 
+The normal command installs dependencies for you. Run `npm install` inside the
+generated project only when you chose `--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@0.4.1 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 reports that specifically scoped proposal-hash
+comparison; it does not claim to check every permutation after more sources are
+added.
+
+Every regular `source-records/*.json` file is discovered in canonical filename
+order, so the generated README experiments work without editing the runner:
+reverse the authority priorities while bumping `policyVersion`, 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
+every canonical record with its complete receipt, the exact loaded
+`@t2kai/core` package version, the complete authority policy, and the full
+forward and reverse reconciliation proposals and issues inside the hashed
+packet. It does not mutate any source record or 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.
+
+After an envelope has been mapped, keep it immutable: represent a later
+observation with a new file, source-record key, payload record ID, and event and
+observation times. Bump `policyVersion` after changing authority priorities;
+bump `mappingVersion` and `ontologyVersion` after changing a mapping; and bump
+`ontologyVersion` for any other ontology contract change.
+
+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.1",
   "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/README.md.template

@@ -4,10 +4,12 @@ This project is a local T2K governed-decision quickstart. Its data is fully
 synthetic.
 
 ```bash
-npm install
 npm start
 ```
 
+`create-t2k` installs dependencies by default. Run `npm install` first only if
+this project was generated with `--no-install`.
+
 The run performs five explicit steps:
 
 1. validate `ontology-pack.json` against the published T2K schema;
@@ -44,6 +46,10 @@ the local containers while preserving their volume, run `npm run db:down`. To
 explicitly delete the disposable local volume and all lifecycle data in it, run
 `npm run db:reset`.
 
+Compose binds PostgreSQL to `127.0.0.1:55432` only. Its `t2k` username and
+`t2k` password are disposable local-only quickstart credentials; never reuse
+them outside this generated project or expose this database to another host.
+
 ## Connect an MCP host
 
 Expose validation, compilation, policy execution, replay, and reward evaluation
@@ -54,7 +60,7 @@ to an MCP host with the safe database-free mode:
   "mcpServers": {
     "t2k": {
       "command": "npx",
-      "args": ["-y", "@t2kai/mcp@latest"]
+      "args": ["-y", "@t2kai/mcp@0.3.0"]
     }
   }
 }
@@ -67,9 +73,15 @@ mutation modes.
 ## Change the example
 
 - Change current facts in `decision-context.json`.
-- Change executable rules in `policies/*.json`.
+- Change executable rules in `policies/*.json` and bump the policy `version`.
 - Add observed outcomes to `episodes/holdout.json` without reusing training data.
-- Change concepts and decision contracts in `ontology-pack.json`.
+- Change concepts or decision contracts in `ontology-pack.json` and bump
+  `ontologyVersion`.
+
+Treat any context, policy, episode, or ontology artifact that has already been
+executed or persisted as immutable evidence. Model a later observation with a
+new context or episode identifier, and keep the prior artifact available for
+replay instead of rewriting history.
 
 The quickstart uses local files, local PostgreSQL, and `@t2kai/core`; it does not
 send data to a hosted service. Set `T2K_DATABASE_URL` to use another Postgres

package/template/compose.yml

@@ -2,6 +2,8 @@ services:
   postgres:
     image: postgres:16-alpine
     environment:
+      # Disposable local-only quickstart credentials. Never reuse t2k/t2k
+      # outside this generated project.
       POSTGRES_DB: t2k_reference
       POSTGRES_PASSWORD: t2k
       POSTGRES_USER: t2k
@@ -11,7 +13,7 @@ services:
       timeout: 5s
       retries: 15
     ports:
-      - "55432:5432"
+      - "127.0.0.1:55432:5432"
     volumes:
       - t2k-reference-data:/var/lib/postgresql/data
 

package/template/package.json.template

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

package/template/src/lifecycle.mjs

@@ -10,8 +10,21 @@ import { compileOntologyPackSet } from "@t2kai/core/compiler";
 import { PostgresReferenceLifecycle } from "@t2kai/core/postgres";
 
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const readJson = async (relativePath) =>
-  JSON.parse(await fs.readFile(path.join(projectRoot, relativePath), "utf8"));
+
+async function readJson(relativePath) {
+  const contents = await fs.readFile(
+    path.join(projectRoot, relativePath),
+    "utf8"
+  );
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    const detail = error instanceof Error ? `: ${error.message}` : "";
+    throw new SyntaxError(`Invalid JSON in ${relativePath}${detail}`, {
+      cause: error,
+    });
+  }
+}
 const [manifest, baseline, candidatePolicy, holdout] = await Promise.all([
   readJson("ontology-pack.json"),
   readJson("policies/baseline.json"),

package/template/src/run.mjs

@@ -12,8 +12,21 @@ import {
 import { compileOntologyPackSet } from "@t2kai/core/compiler";
 
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const readJson = async (relativePath) =>
-  JSON.parse(await fs.readFile(path.join(projectRoot, relativePath), "utf8"));
+
+async function readJson(relativePath) {
+  const contents = await fs.readFile(
+    path.join(projectRoot, relativePath),
+    "utf8"
+  );
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    const detail = error instanceof Error ? `: ${error.message}` : "";
+    throw new SyntaxError(`Invalid JSON in ${relativePath}${detail}`, {
+      cause: error,
+    });
+  }
+}
 
 const [manifest, context, baseline, candidate, episodes] = await Promise.all([
   readJson("ontology-pack.json"),

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,59 @@
+# {{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 start
+```
+
+`create-t2k` installs dependencies by default. Run `npm install` first only if
+this project was generated with `--no-install`.
+
+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. compare the forward source order with its reverse (not every possible
+   ordering when more than two sources exist); and
+6. emit a repeatable 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 canonical record is paired with its complete source-mapping receipt in the
+evidence packet. The packet also includes the exact loaded `@t2kai/core`
+package version, the complete authority policy, both complete reconciliation
+proposals and their issues, and an explicitly scoped forward-versus-reverse
+hash comparison. All of those fields are included 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 safely
+
+- Treat a source envelope as immutable once it has been mapped. To model a
+  later observation, copy it to a new `.json` file and assign a new
+  `sourceRecordKey`, payload `record_id`, `eventTime`, and `observedTime`; never
+  rewrite the earlier envelope.
+- To reverse the priorities in `authority-policy.json`, also bump
+  `policyVersion`, rerun, and inspect the changed proposed authority selection.
+- Add a third synthetic `.json` source with the same `party_key` and its own
+  new envelope identifiers and timestamps; it is discovered automatically on
+  the next run.
+- When a field mapping changes, bump its `mappingVersion`. Because mappings are
+  part of this ontology pack, also bump `ontologyVersion`; bump
+  `ontologyVersion` for any other ontology contract change as well.
+- 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.1"
+  }
+}

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,247 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+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)), "..");
+const loadPackageManifest = createRequire(import.meta.url);
+
+async function readJson(relativePath) {
+  const contents = await fs.readFile(path.join(root, relativePath), "utf8");
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    const detail = error instanceof Error ? `: ${error.message}` : "";
+    throw new SyntaxError(`Invalid JSON in ${relativePath}${detail}`, {
+      cause: error,
+    });
+  }
+}
+
+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 corePackageManifest = loadPackageManifest("@t2kai/core/package.json");
+assert.equal(
+  corePackageManifest.name,
+  "@t2kai/core",
+  "The integration packet must identify the loaded core runtime."
+);
+assert.ok(
+  typeof corePackageManifest.version === "string" &&
+    corePackageManifest.version.length > 0,
+  "The loaded core runtime must expose an exact package version."
+);
+
+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",
+  coreRuntime: {
+    packageName: corePackageManifest.name,
+    packageVersion: corePackageManifest.version,
+  },
+  ontology: `${manifest.ontologyId}@${manifest.ontologyVersion}`,
+  resolutionHash: compilation.resolutionHash,
+  authorityPolicy: structuredClone(authorityPolicy),
+  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,
+      },
+      canonicalRecord: result.canonicalRecord,
+      receipt: result.receipt,
+    }))
+    .sort((left, right) =>
+      compareCanonicalStrings(
+        left.receipt.receiptHash,
+        right.receipt.receiptHash
+      )
+    ),
+  reconciliation: {
+    proposal: reconciliation,
+    reverseInputOrderProposal: reverseOrderReconciliation,
+    forwardReverseInputOrderCheck: {
+      comparisonScope: "forward_and_reverse_input_order_only",
+      allPermutationsChecked: mappedResults.length === 2,
+      forwardReceiptHashes: mappedResults.map(
+        (result) => result.receipt.receiptHash
+      ),
+      reverseReceiptHashes: [...mappedResults]
+        .reverse()
+        .map((result) => result.receipt.receiptHash),
+      forwardProposalHash: reconciliation.proposalHash,
+      reverseProposalHash: reverseOrderReconciliation.proposalHash,
+      proposalHashesMatch:
+        reconciliation.proposalHash === reverseOrderReconciliation.proposalHash,
+    },
+  },
+  humanReview: {
+    status: "pending_human_review",
+    proposalOnly: true,
+    issues: reconciliation.issues,
+  },
+  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));