create-t2k 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+Copyright 2026 T2K contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,26 @@
+# `create-t2k`
+
+Create a runnable local T2K project with a synthetic ontology, accepted facts,
+a Decision Context, two executable policies, and disjoint replay evidence.
+
+```bash
+npx create-t2k my-decision-loop
+cd my-decision-loop
+npm start
+```
+
+The generated run validates and compiles the ontology pack, executes the
+baseline and challenger policies against the current facts, computes a held-out
+replay comparison, and emits a recommendation that still requires explicit
+human authorization.
+
+Use `--no-install` to generate files without running `npm install`:
+
+```bash
+npx create-t2k my-decision-loop --no-install
+```
+
+The command refuses to write into a non-empty directory. Node.js 20.10 or newer
+is required.
+
+Apache-2.0. Contributions require DCO sign-off in the public repository.

package/bin/create-t2k.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { parseArguments, scaffoldProject } from "../src/scaffold.mjs";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageManifest = JSON.parse(
+  await fs.readFile(path.join(packageRoot, "package.json"), "utf8")
+);
+
+const help = `Create a local T2K governed-decision project.
+
+Usage:
+  create-t2k [directory] [options]
+
+Options:
+  --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.`;
+
+try {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    process.stdout.write(`${help}\n`);
+  } else if (options.version) {
+    process.stdout.write(`${packageManifest.version}\n`);
+  } else {
+    await scaffoldProject({
+      targetDirectory: options.targetDirectory,
+      install: options.install,
+      cwd: process.cwd(),
+      stdout: process.stdout,
+    });
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`create-t2k: ${message}\n`);
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "create-t2k",
+  "version": "0.1.0",
+  "description": "Create a local T2K governed-decision project in minutes.",
+  "license": "Apache-2.0",
+  "keywords": [
+    "ontology",
+    "decision-intelligence",
+    "ai-agents",
+    "scaffolding"
+  ],
+  "homepage": "https://t2k.ai/developers/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sigaihealth/t2k-core.git",
+    "directory": "packages/create-t2k"
+  },
+  "bugs": {
+    "url": "https://github.com/sigaihealth/t2k-core/issues"
+  },
+  "type": "module",
+  "bin": {
+    "create-t2k": "./bin/create-t2k.mjs"
+  },
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    "template",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "pack:check": "npm pack --dry-run",
+    "smoke:package": "node scripts/smoke-package.mjs",
+    "release:verify": "node scripts/verify-release-tag.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/scaffold.mjs

@@ -0,0 +1,175 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+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");
+
+export function parseArguments(argumentsList) {
+  const options = {
+    targetDirectory: "my-t2k-project",
+    install: true,
+    help: false,
+    version: false,
+  };
+  const positionals = [];
+  let parseOptions = true;
+
+  for (const argument of argumentsList) {
+    if (parseOptions && argument === "--") {
+      parseOptions = false;
+    } else if (parseOptions && ["-h", "--help"].includes(argument)) {
+      options.help = true;
+    } else if (parseOptions && ["-v", "--version"].includes(argument)) {
+      options.version = true;
+    } else if (parseOptions && argument === "--no-install") {
+      options.install = false;
+    } else if (parseOptions && argument === "--yes") {
+      // The scaffolder has no interactive choices; this keeps npx usage familiar.
+    } else if (parseOptions && argument.startsWith("-")) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else {
+      positionals.push(argument);
+    }
+  }
+
+  if (positionals.length > 1) {
+    throw new Error("Provide at most one project directory.");
+  }
+  if (positionals[0]) {
+    options.targetDirectory = positionals[0];
+  }
+  return options;
+}
+
+function packageNameFor(targetPath) {
+  const name = path.basename(targetPath).toLowerCase();
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) {
+    throw new Error(
+      "The project directory name must use lowercase letters, numbers, dots, dashes, or underscores."
+    );
+  }
+  return name;
+}
+
+async function ensureEmptyDirectory(targetPath) {
+  try {
+    const stat = await fs.lstat(targetPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`Target exists and is not a directory: ${targetPath}`);
+    }
+    const entries = await fs.readdir(targetPath);
+    if (entries.length > 0) {
+      throw new Error(`Target directory is not empty: ${targetPath}`);
+    }
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      await fs.mkdir(targetPath, { recursive: true });
+      return;
+    }
+    throw error;
+  }
+}
+
+async function copyTemplate(sourceDirectory, targetDirectory, replacements) {
+  const entries = await fs.readdir(sourceDirectory, { withFileTypes: true });
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) {
+      throw new Error(`Template symbolic links are not supported: ${entry.name}`);
+    }
+    const outputName = entry.name.endsWith(".template")
+      ? entry.name.slice(0, -".template".length)
+      : entry.name;
+    const sourcePath = path.join(sourceDirectory, entry.name);
+    const targetPath = path.join(targetDirectory, outputName);
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true });
+      await copyTemplate(sourcePath, targetPath, replacements);
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(`Unsupported template entry: ${entry.name}`);
+    }
+    let contents = await fs.readFile(sourcePath, "utf8");
+    for (const [token, value] of Object.entries(replacements)) {
+      contents = contents.replaceAll(token, value);
+    }
+    await fs.writeFile(targetPath, contents, "utf8");
+  }
+}
+
+function run(command, argumentsList, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, argumentsList, {
+      cwd: options.cwd,
+      env: process.env,
+      shell: false,
+      stdio: options.stdio,
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `${command} ${argumentsList.join(" ")} failed${
+              signal ? ` with signal ${signal}` : ` with exit code ${code}`
+            }.`
+          )
+        );
+      }
+    });
+  });
+}
+
+function shellDisplay(value) {
+  return /^[a-zA-Z0-9_./-]+$/.test(value)
+    ? value
+    : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+export async function scaffoldProject({
+  targetDirectory,
+  install = true,
+  cwd = process.cwd(),
+  stdout = process.stdout,
+}) {
+  if (typeof targetDirectory !== "string" || !targetDirectory.trim()) {
+    throw new Error("Project directory is required.");
+  }
+  const targetPath = path.resolve(cwd, targetDirectory);
+  const projectName = packageNameFor(targetPath);
+  await ensureEmptyDirectory(targetPath);
+  await copyTemplate(templateRoot, targetPath, {
+    "{{PROJECT_NAME}}": projectName,
+  });
+
+  if (install) {
+    stdout.write("Installing dependencies...\n");
+    await run(process.platform === "win32" ? "npm.cmd" : "npm", ["install"], {
+      cwd: targetPath,
+      stdio: "inherit",
+    });
+  }
+
+  const relativeTarget = path.relative(cwd, targetPath) || ".";
+  const commandTarget = path.isAbsolute(targetDirectory)
+    ? targetPath
+    : relativeTarget;
+  stdout.write(`\nCreated ${projectName} in ${targetPath}\n\n`);
+  if (commandTarget !== ".") {
+    stdout.write(`  cd ${shellDisplay(commandTarget)}\n`);
+  }
+  if (!install) {
+    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");
+
+  return { targetPath, projectName };
+}

package/template/.gitignore.template

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

package/template/README.md.template

@@ -0,0 +1,31 @@
+# {{PROJECT_NAME}}
+
+This project is a local T2K governed-decision quickstart. Its data is fully
+synthetic.
+
+```bash
+npm install
+npm start
+```
+
+The run performs five explicit steps:
+
+1. validate `ontology-pack.json` against the published T2K schema;
+2. compile the pack and resolve its decision template;
+3. bind accepted facts from `decision-context.json`;
+4. execute baseline and challenger policies;
+5. compute held-out replay evidence and emit a recommendation for human review.
+
+The output is not an autonomous authorization. The generated Decision Context
+requires a `dispatch_owner` to review the evidence and authorize any action.
+
+## Change the example
+
+- Change current facts in `decision-context.json`.
+- Change executable rules in `policies/*.json`.
+- Add observed outcomes to `episodes/holdout.json` without reusing training data.
+- Change concepts and decision contracts in `ontology-pack.json`.
+
+The quickstart uses local files and `@t2kai/core`; it does not send data to a
+hosted service. Persistence, receipts, promotion, and rollback require the
+portable lifecycle runtime or hosted Studio and are not simulated here.

package/template/decision-context.json

@@ -0,0 +1,31 @@
+{
+  "contextKey": "harborlight-dispatch-2026-07-18",
+  "decisionType": "operations.dispatch_overflow",
+  "question": "How should Harborlight respond to the current dispatch queue pressure?",
+  "objective": "Protect on-time service while using the least disruptive reversible response.",
+  "facts": [
+    {
+      "claimKey": "harborlight-current-queue-pressure",
+      "subjectRef": "harborlight-service-business",
+      "predicateRef": "demo.harborlight-field-service:service_business.queue_pressure_ratio",
+      "objectValue": 0.78,
+      "status": "accepted",
+      "sourceRefs": [
+        "manual:dispatch-board-2026-07-18"
+      ]
+    }
+  ],
+  "alternatives": [
+    "hold",
+    "authorize_overtime",
+    "rebalance_route"
+  ],
+  "policies": [
+    "no_unreviewed_dispatch_change",
+    "connector_write_requires_rollback"
+  ],
+  "authority": {
+    "requiredRole": "dispatch_owner",
+    "humanReviewRequired": true
+  }
+}

package/template/episodes/holdout.json

@@ -0,0 +1,322 @@
+[
+  {
+    "episodeId": "holdout-overtime-01",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.61
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-02",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.62
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-03",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.63
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-04",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.64
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-05",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.65
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-06",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.66
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-07",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.67
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-08",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.68
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-09",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.69
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-overtime-10",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.7
+        }
+      ]
+    },
+    "loggedAction": "authorize_overtime",
+    "scalarReward": -0.5,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-01",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.72
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-02",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.73
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-03",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.74
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-04",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.75
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-05",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.76
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-rebalance-06",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.77
+        }
+      ]
+    },
+    "loggedAction": "rebalance_route",
+    "scalarReward": 1,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.1.0"
+  },
+  {
+    "episodeId": "holdout-hold-01",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.21
+        }
+      ]
+    },
+    "loggedAction": "hold",
+    "scalarReward": 0,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-hold-02",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.24
+        }
+      ]
+    },
+    "loggedAction": "hold",
+    "scalarReward": 0,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-hold-03",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.27
+        }
+      ]
+    },
+    "loggedAction": "hold",
+    "scalarReward": 0,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  },
+  {
+    "episodeId": "holdout-hold-04",
+    "state": {
+      "facts": [
+        {
+          "objectValue": 0.3
+        }
+      ]
+    },
+    "loggedAction": "hold",
+    "scalarReward": 0,
+    "learningMode": "supervised_feedback",
+    "behaviorProbability": null,
+    "guardrailViolation": false,
+    "policyVersionId": "harborlight-dispatch@1.0.0"
+  }
+]

package/template/ontology-pack.json

@@ -0,0 +1,129 @@
+{
+  "$schema": "https://t2k.ai/schemas/t2k-ontology-pack.v1.schema.json",
+  "manifestType": "t2k.ontology-pack",
+  "manifestVersion": "1.0",
+  "ontologyVersion": "1.0.0",
+  "ontologyId": "demo.harborlight-field-service",
+  "label": "Harborlight Field Service",
+  "description": "A fully synthetic ontology pack for a governed dispatch decision loop.",
+  "packKind": "vertical",
+  "status": "review",
+  "scope": {
+    "domain": "field_service",
+    "description": "Synthetic service dispatch operations for the T2K quickstart."
+  },
+  "objectTypes": [
+    {
+      "id": "service_business",
+      "label": "Service business",
+      "family": "Operating organization",
+      "nodeKind": "operating-entity",
+      "purpose": "A fictional field-service operator that dispatches work crews.",
+      "identity": [
+        "business_id"
+      ],
+      "properties": [
+        {
+          "id": "queue_pressure_ratio",
+          "valueType": "number",
+          "required": false,
+          "description": "Open urgent jobs divided by available dispatch capacity.",
+          "authorityDomain": "operations",
+          "temporal": true
+        },
+        {
+          "id": "on_time_completion_rate",
+          "valueType": "number",
+          "required": false,
+          "description": "Share of scheduled work completed inside the promised window.",
+          "authorityDomain": "operations",
+          "temporal": true
+        }
+      ]
+    }
+  ],
+  "decisionTemplates": [
+    {
+      "id": "route_overflow",
+      "question": "How should Harborlight respond to the current dispatch queue pressure?",
+      "decisionType": "operations.dispatch_overflow",
+      "requiredContext": [],
+      "requiredFacts": [
+        "demo.harborlight-field-service:service_business.queue_pressure_ratio"
+      ],
+      "objective": "Protect on-time service while using the least disruptive reversible response.",
+      "successMeasure": "The on-time completion rate improves relative to the pre-decision baseline.",
+      "alternatives": [
+        "hold",
+        "authorize_overtime",
+        "rebalance_route"
+      ],
+      "criteria": [
+        "on_time_completion",
+        "reversibility",
+        "crew_load"
+      ],
+      "comparisonMethod": "reference_rule_set",
+      "policies": [
+        "no_unreviewed_dispatch_change"
+      ],
+      "authority": "dispatch_owner",
+      "riskLevel": "L1",
+      "allowedActionProposals": [
+        "dispatch_plan.apply"
+      ],
+      "rollbackExpectation": "Restore the prior dispatch plan if connector reconciliation fails.",
+      "outcomeMeasures": [
+        "demo.harborlight-field-service:service_business.on_time_completion_rate"
+      ],
+      "reviewHorizon": "Review after the seven-day service window.",
+      "learningContract": {
+        "mode": "supervised_feedback",
+        "stateSchema": {
+          "required": [
+            "facts.0.objectValue"
+          ]
+        },
+        "actionSchema": {
+          "allowed": [
+            "hold",
+            "authorize_overtime",
+            "rebalance_route"
+          ]
+        },
+        "rewardSpec": [
+          {
+            "measureRef": "demo.harborlight-field-service:service_business.on_time_completion_rate",
+            "label": "On-time completion rate",
+            "direction": "maximize",
+            "weight": 1,
+            "required": true,
+            "guardrail": false,
+            "unit": "ratio",
+            "observationWindow": "7d",
+            "aggregation": "latest",
+            "baselineMethod": "explicit",
+            "attributionMethod": "human_review"
+          }
+        ],
+        "observationSchedule": [
+          "7d"
+        ],
+        "terminalConditions": [
+          "Seven-day service window complete"
+        ],
+        "explorationPolicy": {
+          "mode": "none"
+        },
+        "safetyConstraints": [
+          "A human dispatch owner authorizes every action",
+          "Every connector write has a rollback contract and receipt"
+        ],
+        "promotionCriteria": {
+          "minimumPassingReplays": 1,
+          "minimumHeldOutEpisodes": 20
+        }
+      }
+    }
+  ]
+}

package/template/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.1.0"
+  }
+}

package/template/policies/baseline.json

@@ -0,0 +1,27 @@
+{
+  "policyKey": "harborlight-dispatch",
+  "version": "1.0.0",
+  "specification": {
+    "referencePolicy": {
+      "rules": [
+        {
+          "all": [
+            {
+              "path": "facts.0.objectValue",
+              "operator": "gte",
+              "value": 0.6
+            }
+          ],
+          "action": "authorize_overtime"
+        }
+      ],
+      "defaultAction": "hold",
+      "evaluation": {
+        "minimumEpisodes": 20,
+        "minimumImprovement": 0.05,
+        "confidenceZ": 1.96,
+        "minimumCoverage": 0.2
+      }
+    }
+  }
+}

package/template/policies/candidate.json

@@ -0,0 +1,28 @@
+{
+  "policyKey": "harborlight-dispatch",
+  "version": "1.1.0",
+  "status": "proposed",
+  "specification": {
+    "referencePolicy": {
+      "rules": [
+        {
+          "all": [
+            {
+              "path": "facts.0.objectValue",
+              "operator": "gte",
+              "value": 0.6
+            }
+          ],
+          "action": "rebalance_route"
+        }
+      ],
+      "defaultAction": "hold",
+      "evaluation": {
+        "minimumEpisodes": 20,
+        "minimumImprovement": 0.05,
+        "confidenceZ": 1.96,
+        "minimumCoverage": 0.2
+      }
+    }
+  }
+}

package/template/src/run.mjs

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  aggregatePolicyRewards,
+  evaluateReferencePolicy,
+  evaluateReferenceReplay,
+  validateOntologyPackManifest,
+} from "@t2kai/core";
+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"));
+
+const [manifest, context, baseline, candidate, episodes] = await Promise.all([
+  readJson("ontology-pack.json"),
+  readJson("decision-context.json"),
+  readJson("policies/baseline.json"),
+  readJson("policies/candidate.json"),
+  readJson("episodes/holdout.json"),
+]);
+
+const validation = validateOntologyPackManifest(manifest);
+assert.equal(
+  validation.valid,
+  true,
+  `Ontology validation failed: ${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 decisionTemplate = compilation.definitions.find(
+  (definition) =>
+    definition.definitionKind === "decision_template" &&
+    definition.body.decisionType === context.decisionType
+);
+assert.ok(decisionTemplate, `No compiled template for ${context.decisionType}`);
+const acceptedFactRefs = new Set(
+  context.facts
+    .filter((fact) => fact.status === "accepted")
+    .map((fact) => fact.predicateRef)
+);
+for (const requiredFact of decisionTemplate.body.requiredFacts ?? []) {
+  assert.ok(acceptedFactRefs.has(requiredFact), `Missing accepted fact: ${requiredFact}`);
+}
+assert.equal(
+  context.authority.humanReviewRequired,
+  true,
+  "The quickstart must not silently authorize its recommendation."
+);
+
+const state = { facts: context.facts };
+const baselineAction = evaluateReferencePolicy(baseline.specification, state);
+const candidateAction = evaluateReferencePolicy(candidate.specification, state);
+const replay = evaluateReferenceReplay({
+  candidateSpecification: candidate.specification,
+  baselineSpecification: baseline.specification,
+  episodes: episodes.map(({ policyVersionId: _policyVersionId, ...episode }) => episode),
+});
+assert.equal(replay.status, "passed", "The challenger must pass computed replay.");
+assert.equal(replay.candidate.guardrailViolations, 0);
+
+const rewardAggregates = aggregatePolicyRewards(
+  episodes.map((episode) => ({
+    policyVersionId: episode.policyVersionId,
+    scalarReward: episode.scalarReward,
+    guardrailViolation: episode.guardrailViolation,
+  }))
+);
+const result = {
+  ontology: `${manifest.ontologyId}@${manifest.ontologyVersion}`,
+  resolutionHash: compilation.resolutionHash,
+  decisionContext: {
+    contextKey: context.contextKey,
+    decisionType: context.decisionType,
+    acceptedFacts: acceptedFactRefs.size,
+  },
+  reasoning: {
+    baseline: { version: baseline.version, action: baselineAction },
+    candidate: { version: candidate.version, action: candidateAction },
+  },
+  replay: {
+    status: replay.status,
+    sampleSize: replay.sampleSize,
+    estimatedImprovement: replay.estimatedImprovement,
+    improvementConfidenceLower: replay.improvementConfidenceLower,
+    candidateCoverage: replay.candidate.coverage,
+    baselineCoverage: replay.baseline.coverage,
+    guardrailViolations: replay.candidate.guardrailViolations,
+  },
+  rewardAggregates,
+  recommendation: {
+    action: candidateAction,
+    policyVersion: candidate.version,
+    status: "eligible_for_human_review",
+  },
+  authorization: {
+    requiredRole: context.authority.requiredRole,
+    status: "not_authorized",
+  },
+};
+
+console.log(JSON.stringify(result, null, 2));