@ngockhoale/ukit 3.0.0 → 3.0.2

package/src/core/executionContracts.js

@@ -4,8 +4,8 @@
 // this file:
 //   - src/index/taskRouting.js  (in-process routing: contracts + risk profiles + mode order)
 //   - src/core/runtimeConfig.js (config defaults: contracts minus runtime-only keys)
-//   - templates/ukit/storage/config.json (literal mirror of the config defaults)
-//   - templates/.claude/ukit/index/route-task.mjs (shipped standalone CLI: contracts + tiers)
+//   - template_project/ukit/storage/config.json (literal mirror of the config defaults)
+//   - template_project/.claude/ukit/index/route-task.mjs (shipped standalone CLI: contracts + tiers)
 //
 // route-task.mjs runs inside target projects and cannot import from src/, so it keeps a
 // literal copy — tests/consistency/executionContractSync.test.js locks that copy to these
@@ -90,6 +90,46 @@ export const MODEL_TIER_BY_CONTRACT = {
   'review-release': 'smart',
 };
 
+// Decision table v2 (V3_RESHAPE §5): MODEL_TIER_BY_CONTRACT stays the base row;
+// resolveModelTier adds the (riskFloor, hostCapabilities) columns. Deterministic —
+// no registry, no leases, no outbound capability calls.
+export const ROUTE_EFFORTS = new Set(['low', 'medium', 'high']);
+
+// Tier ladder for the one-band high-risk escalation; effort rides the resolved tier.
+const MODEL_TIER_ORDER = ['lite', 'code', 'smart'];
+const MODEL_TIER_EFFORT = {
+  lite: 'low',
+  code: 'medium',
+  smart: 'high',
+};
+
+/**
+ * Resolves {tier, effort, advisoryOnly} for a route. A 'high-risk' floor escalates
+ * the tier one band (lite→code→smart, capped at smart) and forces effort 'high'.
+ * Unknown mode → {tier:null, effort:null, advisoryOnly:true}. Missing/unknown
+ * riskFloor → 'none'. Missing hostCapabilities → advisoryOnly:true (the route text
+ * is all the host gets when it cannot bind model and effort).
+ */
+export function resolveModelTier({
+  executionMode = null,
+  riskFloor = null,
+  hostCapabilities = null,
+} = {}) {
+  const baseTier = MODEL_TIER_BY_CONTRACT[executionMode] ?? null;
+  if (!baseTier) {
+    return { tier: null, effort: null, advisoryOnly: true };
+  }
+  const highRisk = riskFloor?.floor === 'high-risk';
+  const tier = highRisk
+    ? MODEL_TIER_ORDER[Math.min(MODEL_TIER_ORDER.indexOf(baseTier) + 1, MODEL_TIER_ORDER.length - 1)]
+    : baseTier;
+  return {
+    tier,
+    effort: highRisk ? 'high' : MODEL_TIER_EFFORT[tier],
+    advisoryOnly: !(hostCapabilities?.canBindModel === true && hostCapabilities?.canBindEffort === true),
+  };
+}
+
 export const CONTRACT_RISK_PROFILES = {
   'tiny-fix': { riskLevel: 'minimal', contextPolicy: 'confirm-target-only' },
   'local-fix': { riskLevel: 'local', contextPolicy: 'bounded-local' },

package/src/core/fileOps.js

@@ -2,9 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 // The shipped runtime carries the single lock implementation; src and the
-// installed package always ship templates/ together (package.json files list),
+// installed package always ship template_project/ together (package.json files list),
 // so the protocol twin delegates instead of keeping a driftable copy.
-import { journalDroppedLockMutation, withAsyncLock, withTransientFsRetry } from '../../templates/.claude/ukit/runtime/async-lock.mjs';
+import { journalDroppedLockMutation, withAsyncLock, withTransientFsRetry } from '../../template_project/.claude/ukit/runtime/async-lock.mjs';
 
 export async function pathExists(targetPath) {
   try {
@@ -185,7 +185,7 @@ const LOCK_MAX_WAIT_MS = 5_000;
  * flows in one process (parallel subagents). The lock is a directory created next
  * to the target file: `mkdir` is atomic, so exactly one caller can create it.
  *
- * The entire lock protocol lives in templates/.claude/ukit/runtime/async-lock.mjs
+ * The entire lock protocol lives in template_project/.claude/ukit/runtime/async-lock.mjs
  * (TASK-004 fix round 1): owner stamping (pid + token + pstart), recycled-pid
  * detection via recordedProcessGone, claim+quarantine stale reclaim, and verified
  * release exist exactly once there — this function and the token-utils.mjs twin

package/src/core/gatewayProbe.js

@@ -10,7 +10,7 @@
  *     error envelope slip through and kill the user's turn.
  *
  * Self-contained and hermetic: `fetchImpl` is injectable. `resolveGatewayBaseUrl` mirrors the
- * 3-tier probe order from templates/.claude/ukit/index/unic-gateway.mjs (env → project
+ * 3-tier probe order from template_project/.claude/ukit/index/unic-gateway.mjs (env → project
  * .claude/settings.json → home ~/.claude/settings.json) but is intentionally duplicated
  * here per PLAN.md §3 (cross-task coupling is the cheaper-than-it-looks debt — see plan).
  *
@@ -65,7 +65,7 @@ function readSettingsBaseUrl(filePath) {
 
 /**
  * Detects the current custom-gateway base URL using the same 3-tier probe order as
- * `templates/.claude/ukit/index/unic-gateway.mjs` (generalized — fires on any non-empty
+ * `template_project/.claude/ukit/index/unic-gateway.mjs` (generalized — fires on any non-empty
  * value, not only the UNIC token):
  *   1. env.ANTHROPIC_BASE_URL
  *   2. <projectRoot>/.claude/settings.json -> env.ANTHROPIC_BASE_URL

package/src/core/gatewayResilienceEnv.js

@@ -24,7 +24,7 @@ import path from 'node:path';
 // defaults on the next install instead of being mistaken for user intent. Re-running
 // `ukit install` is a no-op once the keys are in place.
 //
-// Probe order mirrors `templates/.claude/ukit/index/unic-gateway.mjs` (env → project
+// Probe order mirrors `template_project/.claude/ukit/index/unic-gateway.mjs` (env → project
 // `.claude/settings.json` env → home `~/.claude/settings.json` env) but generalizes to ANY
 // non-empty `ANTHROPIC_BASE_URL`, not only `unicjsc.com`. The runtime template stays
 // scoped to UNIC because that's the lane-routing signal; here we only care that the user
@@ -82,7 +82,7 @@ function readBaseUrlFromSettingsFileSync(settingsPath) {
 
 /**
  * Detect whether ANY non-empty ANTHROPIC_BASE_URL is in scope, mirroring the probe order of
- * `templates/.claude/ukit/index/unic-gateway.mjs` but generalized. Probe order is strictly
+ * `template_project/.claude/ukit/index/unic-gateway.mjs` but generalized. Probe order is strictly
  * env → project `.claude/settings.json` → home `~/.claude/settings.json`; first non-empty
  * hit wins, and the returned `source` tells the caller which one matched.
  *

package/src/core/handoffDocValidator.js

@@ -0,0 +1,152 @@
+// handoffDocValidator.js — TASK-004 / Cycle C50 (mechanic #10, FR-007)
+//
+// Mechanical structure gate for handoff docs. Unlike taskBudgetValidator (advisory,
+// exit 0), this validator is a REAL gate: the CLI twin exits 1 on any violation.
+// Keep that difference explicit — do not "fix" the exit code.
+//
+// Exports:
+//   validateHandoffDoc(markdown, kind) → { ok: boolean, failures: string[] }
+//     kind ∈ 'plan' | 'task' | 'executor-report'
+//
+// Rules (SPEC §5 FR-007):
+//   plan            — `## §1`..`## §6` headings present and in ascending order
+//                     (extra trailing sections allowed), `## Planner Report`
+//                     section containing `PLANNER_MODEL:`.
+//   task            — required `## ` sections: Goal, Target Files, Test Cases,
+//                     Test Files, Verification Commands, Acceptance Criteria,
+//                     Dependencies, Interfaces; plus a `- Status:` field.
+//                     When the doc also carries `## Executor Report`, the report
+//                     header fields are validated too.
+//   executor-report — required fields: EXECUTOR_TOOL, EXECUTOR_MODEL,
+//                     EXECUTOR_SUBAGENT, RED_OUTPUT.
+//
+// Parsing is deliberately markdown-light and dependency-free so the logic can be
+// duplicated byte-for-byte into the shipped CLI twin
+// (template_project/.claude/ukit/index/handoff-doc-validator.mjs) without
+// dragging `src/` into user installs — same pattern as taskBudgetValidator (C12).
+
+const PLAN_SECTIONS = ['§1', '§2', '§3', '§4', '§5', '§6'];
+
+const TASK_SECTIONS = [
+  'Goal',
+  'Target Files',
+  'Test Cases',
+  'Test Files',
+  'Verification Commands',
+  'Acceptance Criteria',
+  'Dependencies',
+  'Interfaces',
+];
+
+const REPORT_FIELDS = ['EXECUTOR_TOOL', 'EXECUTOR_MODEL', 'EXECUTOR_SUBAGENT', 'RED_OUTPUT'];
+
+// Section helpers. Any line starting with `## ` opens a section; the body runs
+// until the next `## ` line or EOF. Returns [{ name, body, pos }] in file order.
+function splitSections(markdown) {
+  const sections = [];
+  const lines = String(markdown).split('\n');
+  let current = null;
+  lines.forEach((line, idx) => {
+    const m = line.match(/^##\s+(.+?)\s*$/);
+    if (m) {
+      current = { name: m[1], body: '', pos: idx };
+      sections.push(current);
+    } else if (current) {
+      current.body += line + '\n';
+    }
+  });
+  return sections;
+}
+
+// Positions of `## §<n>` headings, keyed by the literal token ('§1'..'§6').
+// A heading matches when its name starts with the token (`## §1 Intent`).
+function planSectionPositions(sections) {
+  const positions = new Map();
+  for (const s of sections) {
+    for (const token of PLAN_SECTIONS) {
+      if (!positions.has(token) && s.name.startsWith(token)) positions.set(token, s.pos);
+    }
+  }
+  return positions;
+}
+
+function hasSection(sections, name) {
+  return sections.some((s) => s.name === name || s.name.startsWith(`${name} `) || s.name.startsWith(`${name}(`));
+}
+
+function getSection(sections, name) {
+  return sections.find((s) => s.name === name || s.name.startsWith(`${name} `) || s.name.startsWith(`${name}(`));
+}
+
+function validatePlan(markdown) {
+  const failures = [];
+  const sections = splitSections(markdown);
+  const positions = planSectionPositions(sections);
+
+  for (const token of PLAN_SECTIONS) {
+    if (!positions.has(token)) failures.push(`missing required section heading "## ${token}"`);
+  }
+
+  // Order check over the sections that exist: each must appear after the
+  // highest position seen so far.
+  let maxPos = -1;
+  for (const token of PLAN_SECTIONS) {
+    const pos = positions.get(token);
+    if (pos === undefined) continue;
+    if (pos < maxPos) {
+      failures.push(`section order violation: "## ${token}" appears after a later section`);
+    } else {
+      maxPos = pos;
+    }
+  }
+
+  const report = getSection(sections, 'Planner Report');
+  if (!report) {
+    failures.push('missing required section "## Planner Report"');
+  } else if (!/^PLANNER_MODEL\s*:/m.test(report.body)) {
+    failures.push('missing required field "PLANNER_MODEL:" inside "## Planner Report"');
+  }
+
+  return failures;
+}
+
+function validateExecutorReportFields(markdown, prefix) {
+  const failures = [];
+  for (const field of REPORT_FIELDS) {
+    if (!new RegExp(`^${field}\\s*:`, 'm').test(markdown)) {
+      failures.push(`${prefix}missing required field "${field}:"`);
+    }
+  }
+  return failures;
+}
+
+function validateTask(markdown) {
+  const failures = [];
+  const sections = splitSections(markdown);
+
+  for (const name of TASK_SECTIONS) {
+    if (!hasSection(sections, name)) failures.push(`missing required section "## ${name}"`);
+  }
+  if (!/^\s*-?\s*Status\s*:/m.test(markdown)) {
+    failures.push('missing required field "Status:"');
+  }
+
+  // A task file that already carries an Executor Report must satisfy the
+  // report header contract too (FR-007).
+  const report = getSection(sections, 'Executor Report');
+  if (report) {
+    failures.push(...validateExecutorReportFields(report.body, 'executor-report: '));
+  }
+
+  return failures;
+}
+
+export function validateHandoffDoc(markdown, kind) {
+  const text = String(markdown ?? '');
+  let failures;
+  if (kind === 'plan') failures = validatePlan(text);
+  else if (kind === 'task') failures = validateTask(text);
+  else if (kind === 'executor-report') failures = validateExecutorReportFields(text, '');
+  else failures = [`unknown kind "${kind}" (expected plan|task|executor-report)`];
+  return { ok: failures.length === 0, failures };
+}

package/src/core/output/index.js

@@ -354,7 +354,7 @@ function buildRecoveryHintSummary(summary, rawPath, { tokensBefore = 0 } = {}) {
 }
 
 // --- tee/ cache bound (BUG-C21-07, FR-006) -----------------------------------
-// Mirror of the bound in templates/.claude/ukit/runtime/output-compression.mjs —
+// Mirror of the bound in template_project/.claude/ukit/runtime/output-compression.mjs —
 // keep the two implementations identical. persistRawOutput wrote one preserved
 // file per compression and nothing ever deleted from tee/. Sweeps are SAMPLED
 // (~1/16 writes, UKIT_TEE_SWEEP_PROBABILITY to force/disable) and BOUNDED

package/src/core/paths.js

@@ -6,7 +6,8 @@ export function buildPathConfig({ packageRoot, projectRoot }) {
     projectRoot,
     manifestPath: path.join(packageRoot, 'manifests', 'platform.full.yaml'),
     userManifestPath: path.join(packageRoot, 'manifests', 'platform.user.yaml'),
-    templatesRoot: path.join(packageRoot, 'templates'),
+    templatesRoot: path.join(packageRoot, 'template_project'),
+    userTemplatesRoot: path.join(packageRoot, 'template_user'),
     ukitRoot: path.join(projectRoot, '.claude', 'ukit', '.ukit'),
     installMetaPath: path.join(projectRoot, '.claude', 'ukit', '.ukit', 'install.json'),
     backupRoot: path.join(projectRoot, '.claude', 'ukit', '.ukit', 'backups'),

package/src/core/reviewPanelAggregate.js

@@ -0,0 +1,120 @@
+// reviewPanelAggregate.js — TASK-004 / Cycle C50 (mechanic #10, FR-008)
+//
+// Deterministic aggregation of `## Reviewer Verdict` blocks written by the
+// `modelRoles['review-panel']` diversity-review panel (mechanic #6). The
+// orchestrator stays context-lean: this script does the consensus math.
+//
+// Exports:
+//   parseVerdictBlock(text) → { member, verdict, findings } | null
+//   aggregatePanelVerdicts(verdicts: string[]) →
+//     { agreementMap: [{ finding, members[] }],
+//       verdict: 'approved' | 'approved_minor' | 'changes_requested',
+//       highSignal: [{ finding, members[] }],
+//       unparsed: string[] }
+//
+// Consensus rules (SPEC §5 FR-008):
+//   changes_requested — ≥1 CRITICAL verdict, ≥1 critical-severity finding,
+//                       or ≥2 CHANGES-REQUESTED verdicts.
+//   approved          — ≥2 APPROVED verdicts and no critical.
+//   approved_minor    — everything else (incl. degenerate/empty panel).
+//
+// High signal: a finding reported by ≥2 panel members, or any critical-severity
+// finding (a lone critical must never be buried below the lead's judgment).
+//
+// Advisory class: the CLI twin always exits 0.
+//
+// Parsing is deliberately markdown-light and dependency-free so the logic can be
+// duplicated byte-for-byte into the shipped CLI twin
+// (template_project/.claude/ukit/index/review-panel-aggregate.mjs) — same
+// pattern as taskBudgetValidator (C12).
+
+const SEVERITIES = ['critical', 'important', 'minor'];
+
+// Parse one `## Reviewer Verdict` block (format: code-reviewer.md §Output).
+// Returns null when no recognizable VERDICT line exists — the block is then
+// counted as absent and named in `unparsed`.
+export function parseVerdictBlock(text) {
+  const src = String(text ?? '');
+  const verdictMatch = src.match(/^VERDICT\s*:\s*(APPROVED-WITH-MINOR|APPROVED|CHANGES-REQUESTED|CRITICAL)\s*$/im);
+  if (!verdictMatch) return null;
+
+  const memberMatch = src.match(/^PANEL_MEMBER\s*:\s*(\S+)\s*$/im);
+  const member = memberMatch && memberMatch[1] !== '-' ? memberMatch[1] : null;
+
+  const findings = { critical: [], important: [], minor: [] };
+  const findingsMatch = src.match(/^FINDINGS:\s*$/im);
+  if (findingsMatch) {
+    const rest = src.slice(findingsMatch.index + findingsMatch[0].length);
+    let severity = null;
+    for (const line of rest.split('\n')) {
+      if (/^\S/.test(line)) break; // next top-level field ends FINDINGS
+      const sev = line.match(/^\s{2}(critical|important|minor)\s*:/);
+      if (sev) {
+        severity = sev[1];
+        continue;
+      }
+      const item = line.match(/^\s{4}-\s+(.+?)\s*$/);
+      if (item && severity) {
+        const text2 = item[1];
+        if (text2 !== 'none' && text2 !== '-') findings[severity].push(text2);
+      }
+    }
+  }
+
+  return { member, verdict: verdictMatch[1].toUpperCase(), findings };
+}
+
+// Normalize a finding bullet for identity comparison: two members report the
+// "identical finding" when the normalized text matches.
+function normalizeFinding(text) {
+  return String(text).replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+export function aggregatePanelVerdicts(verdicts) {
+  const list = Array.isArray(verdicts) ? verdicts : [];
+  const parsed = [];
+  const unparsed = [];
+
+  list.forEach((block, i) => {
+    const p = parseVerdictBlock(block);
+    if (p) parsed.push({ ...p, label: p.member || `verdict[${i}]` });
+    else unparsed.push(`verdict[${i}]`);
+  });
+
+  // Agreement Map: finding → set of panel members reporting it.
+  const map = new Map(); // normalized → { finding, members:Set, critical:boolean }
+  for (const p of parsed) {
+    for (const sev of SEVERITIES) {
+      for (const f of p.findings[sev]) {
+        const key = normalizeFinding(f);
+        let entry = map.get(key);
+        if (!entry) {
+          entry = { finding: f, members: new Set(), critical: sev === 'critical' };
+          map.set(key, entry);
+        }
+        entry.members.add(p.label);
+        if (sev === 'critical') entry.critical = true;
+      }
+    }
+  }
+
+  const agreementMap = [...map.values()].map((e) => ({
+    finding: e.finding,
+    members: [...e.members],
+  }));
+  const highSignal = [...map.values()]
+    .filter((e) => e.members.size >= 2 || e.critical)
+    .map((e) => ({ finding: e.finding, members: [...e.members] }));
+
+  const approvals = parsed.filter((p) => p.verdict === 'APPROVED').length;
+  const changeRequests = parsed.filter((p) => p.verdict === 'CHANGES-REQUESTED').length;
+  const hasCritical =
+    parsed.some((p) => p.verdict === 'CRITICAL') || parsed.some((p) => p.findings.critical.length > 0);
+
+  let verdict;
+  if (hasCritical || changeRequests >= 2) verdict = 'changes_requested';
+  else if (approvals >= 2) verdict = 'approved';
+  else verdict = 'approved_minor';
+
+  return { agreementMap, verdict, highSignal, unparsed };
+}

package/src/core/runInstallPipeline.js

@@ -274,16 +274,18 @@ async function runUserLayerPass({
     // project install — the whole pass is advisory.
     const userPaths = buildUserPaths({ homeDir });
     userLayer.userRoot = userPaths.userRoot;
-    // pathConfig.userManifestPath is set by buildPathConfig; fall back to the
-    // package layout (templatesRoot's sibling manifests/) for callers that build
-    // pathConfig by hand (tests, embedded runners).
+    // pathConfig.userManifestPath / userTemplatesRoot are set by buildPathConfig;
+    // fall back to the package layout (templatesRoot's siblings manifests/ and
+    // template_user/) for callers that build pathConfig by hand.
     const userManifestPath = pathConfig.userManifestPath
       ?? path.join(pathConfig.templatesRoot, '..', 'manifests', 'platform.user.yaml');
+    const userTemplatesRoot = pathConfig.userTemplatesRoot
+      ?? path.join(pathConfig.templatesRoot, '..', 'template_user');
     const userManifest = await loadManifest(userManifestPath);
     const userPlan = await buildInstallPlan({
       manifest: userManifest,
       stackContext,
-      templatesRoot: pathConfig.templatesRoot,
+      templatesRoot: userTemplatesRoot,
       variables,
       projectRoot: userPaths.userRoot,
       selectedAdapterItemIds,

package/src/core/runtimeConfig.js

@@ -259,6 +259,9 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
     // key treats absence as "off"; stages promote off -> shadow -> canary -> default.
     routing: {
       routeSchema: { stage: 'off' },
+      rigor: { stage: 'off' },
+      fastPath: { stage: 'off' },
+      escalation: { stage: 'off' },
     },
     // SPEC-model-roles: role→tier map injected into delegating-lane route output.
     // Values are tier names or 'inherit-parent' — never raw provider model IDs.
@@ -537,12 +540,16 @@ export function validateRuntimeConfig(config) {
       errors.push('routing must be an object.');
     } else {
       const VALID_ROUTE_STAGES = new Set(['off', 'shadow', 'canary', 'default']);
-      if (config.routing.routeSchema !== undefined) {
-        if (!isPlainObject(config.routing.routeSchema)) {
-          errors.push('routing.routeSchema must be an object.');
-        } else if (config.routing.routeSchema.stage !== undefined
-          && !VALID_ROUTE_STAGES.has(config.routing.routeSchema.stage)) {
-          errors.push(`routing.routeSchema.stage must be one of: ${[...VALID_ROUTE_STAGES].join(', ')}.`);
+      for (const key of ['routeSchema', 'rigor', 'fastPath', 'escalation']) {
+        const stageKey = config.routing[key];
+        if (stageKey === undefined) {
+          continue;
+        }
+        if (!isPlainObject(stageKey)) {
+          errors.push(`routing.${key} must be an object.`);
+        } else if (stageKey.stage !== undefined
+          && !VALID_ROUTE_STAGES.has(stageKey.stage)) {
+          errors.push(`routing.${key}.stage must be one of: ${[...VALID_ROUTE_STAGES].join(', ')}.`);
         }
       }
     }

package/src/core/sensitiveValueScanner.js

@@ -2,7 +2,7 @@
  * sensitiveValueScanner.js (TASK-036)
  *
  * Shared source-side extraction of the high-confidence secret *value* scanner
- * that lives in templates/.claude/hooks/sensitive-data-guard.sh. One semantic
+ * that lives in template_project/.claude/hooks/sensitive-data-guard.sh. One semantic
  * implementation is consumed by the runtime hook mirror (TASK-038/039) and the
  * PROJECT_IMPORTANT.md renderer (TASK-037).
  *

package/src/core/taskBudgetValidator.js

@@ -27,7 +27,7 @@
 //                               never crash.
 //
 // Parsing is deliberately markdown-light and dependency-free so the validator can be
-// duplicated byte-for-byte into the shipped CLI twin (templates/.claude/ukit/index/
+// duplicated byte-for-byte into the shipped CLI twin (template_project/.claude/ukit/index/
 // task-budget-validator.mjs) without dragging `src/` into user installs.
 
 export const DEFAULT_CRITERIA = Object.freeze({

package/src/core/unattendedDoctor.js

@@ -57,7 +57,7 @@ function execOmpConfigGet(projectRoot, ompPath) {
 
 async function readTemplateDenyMatches() {
   try {
-    const text = await fs.readFile(path.join(PACKAGE_ROOT, 'templates', '.omp', 'config.yml'), 'utf8');
+    const text = await fs.readFile(path.join(PACKAGE_ROOT, 'template_project', '.omp', 'config.yml'), 'utf8');
     const parsed = parse(text.replace(TEMPLATE_PLACEHOLDER_PATTERN, '0'));
     const patterns = parsed?.bash?.patterns;
     if (!Array.isArray(patterns)) return [];

package/src/core/update.js

@@ -21,7 +21,7 @@ const INSTALLED_MARKERS = ['.ukit', '.claude', 'CLAUDE.md', 'AGENTS.md', '.codex
 // signal-ignoring child blocks indefinitely, SIGKILL returns ~immediately with
 // ETIMEDOUT. Direct-child kill only (no process-group tree kill): these are
 // short-lived CLI one-shots; the detached-group TERM→KILL posture stays in
-// templates/.claude/ukit/runtime/hook-process.mjs where hooks need it.
+// template_project/.claude/ukit/runtime/hook-process.mjs where hooks need it.
 export const NPM_QUERY_TIMEOUT_MS = 15_000;
 export const NPM_INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
 const KILL_ON_TIMEOUT = 'SIGKILL';

package/src/index/buildIndex.js

@@ -1910,7 +1910,7 @@ function areBugIndexSnapshotsEqual(previousSnapshot, nextSnapshot) {
  * fell back to the project root when NONE of them existed. Partial matches were
  * the trap: a repo with a top-level `tests/` but its code in `packages/` indexed
  * `tests/` and silently nothing else. UKit's own repo hit exactly that — `src`,
- * `tests` and `manifests` all exist, so `templates/` (the entire shipped payload)
+ * `tests` and `manifests` all exist, so `template_project/` (the entire shipped payload)
  * was never indexed, and three releases shipped features that were dead on
  * arrival because the index kept pointing at `src/` and the hand-maintained
  * `.claude/` dev mirror instead.
@@ -2115,7 +2115,7 @@ async function collectGitTrackedFiles(rootDir, discovery = null) {
       return false;
     }
     // Git already applied the project's own ignore rules, so dot-directories it
-    // still lists are deliberate (UKit's `templates/.claude/**` is force-added).
+    // still lists are deliberate (UKit's `template_project/.claude/**` is force-added).
     // All that is left to defend against is a build directory someone committed.
     return !relativePath.split('/').some((segment) => EXCLUDED_DIR_NAMES.has(segment));
   });

package/src/index/impactCatalog.js

@@ -24,11 +24,11 @@ const SHARED_IMPACT_PATTERNS = [
     label: 'shared-token-runtime',
   },
   {
-    regex: /^templates\/\.claude\/hooks\//,
+    regex: /^template_project\/\.claude\/hooks\//,
     label: 'installed-hook-runtime',
   },
   {
-    regex: /^templates\/\.claude\/ukit\//,
+    regex: /^template_project\/\.claude\/ukit\//,
     label: 'installed-helper-runtime',
   },
   {
@@ -36,7 +36,7 @@ const SHARED_IMPACT_PATTERNS = [
     label: 'install-manifest',
   },
   {
-    regex: /^templates\//,
+    regex: /^template_project\//,
     label: 'published-template-surface',
   },
 ];
@@ -44,47 +44,47 @@ const SHARED_IMPACT_PATTERNS = [
 const MIRROR_PAIRS = [
   {
     source: 'src/index/buildIndex.js',
-    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    mirror: 'template_project/.claude/ukit/index/lib/index-core.mjs',
     reason: 'installed index-core mirror embeds source index behavior',
   },
   {
     source: 'src/index/queryIndex.js',
-    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    mirror: 'template_project/.claude/ukit/index/lib/index-core.mjs',
     reason: 'installed index-core mirror embeds source query behavior',
   },
   {
     source: 'src/index/resolveContext.js',
-    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    mirror: 'template_project/.claude/ukit/index/lib/index-core.mjs',
     reason: 'installed index-core mirror embeds context resolution behavior',
   },
   {
     source: 'src/index/verificationPlan.js',
-    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    mirror: 'template_project/.claude/ukit/index/lib/index-core.mjs',
     reason: 'installed index-core mirror embeds verification planning behavior',
   },
   {
     source: 'src/index/taskRouting.js',
-    mirror: 'templates/.claude/ukit/index/route-task.mjs',
+    mirror: 'template_project/.claude/ukit/index/route-task.mjs',
     reason: 'installed route-task helper mirrors source task routing behavior',
   },
   {
     source: 'src/index/routeCatalog.js',
-    mirror: 'templates/.claude/ukit/index/route-catalog.mjs',
+    mirror: 'template_project/.claude/ukit/index/route-catalog.mjs',
     reason: 'installed route catalog must match source route catalog',
   },
   {
     source: 'src/core/output/index.js',
-    mirror: 'templates/.claude/ukit/runtime/output-compression.mjs',
+    mirror: 'template_project/.claude/ukit/runtime/output-compression.mjs',
     reason: 'source output compression runtime should stay aligned with installed hook runtime',
   },
   {
     source: 'src/core/token/index.js',
-    mirror: 'templates/.claude/ukit/runtime/token-utils.mjs',
+    mirror: 'template_project/.claude/ukit/runtime/token-utils.mjs',
     reason: 'source token runtime should stay aligned with installed token utilities',
   },
   {
     source: 'src/core/compact/threshold.js',
-    mirror: 'templates/.claude/ukit/runtime/compact-threshold.mjs',
+    mirror: 'template_project/.claude/ukit/runtime/compact-threshold.mjs',
     reason: 'source compact threshold runtime should stay aligned with installed compact threshold hook',
   },
 ];