@ngockhoale/ukit 3.4.46 → 3.4.48

package/src/core/executionContracts.js

@@ -95,37 +95,39 @@ export const MODEL_TIER_BY_CONTRACT = {
 // 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'];
+// Tier, effort and risk are independent decisions. Effort is Medium for every tier (Low for chores);
+// High needs complexity evidence (`complexityEvidence` below), never risk or tier alone.
 const MODEL_TIER_EFFORT = {
   lite: 'low',
   code: 'medium',
-  smart: 'high',
+  smart: 'medium',
 };
 
 /**
- * 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).
+ * Resolves {tier, effort, advisoryOnly} for a route. A 'high-risk' floor lifts a Tier 1 chore to the
+ * Tier 2 executor (lite→code) and goes no further: smart is the orchestrator / acceptance tier and is
+ * reached only through its own contract (review-release) or failure evidence, never through risk, so
+ * risk cannot turn the orchestrator into the implementation worker. Risk raises verification rigor
+ * (the route's riskFloor / rigor), not the tier ceiling or the effort. Effort is 'high' only with
+ * `complexityEvidence`. 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,
+  complexityEvidence = false,
 } = {}) {
   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;
+  const tier = highRisk && baseTier === 'lite' ? 'code' : baseTier;
   return {
     tier,
-    effort: highRisk ? 'high' : MODEL_TIER_EFFORT[tier],
+    effort: complexityEvidence === true ? 'high' : MODEL_TIER_EFFORT[tier],
     advisoryOnly: !(hostCapabilities?.canBindModel === true && hostCapabilities?.canBindEffort === true),
   };
 }
@@ -204,12 +206,55 @@ function neutralizeNonOrders(text) {
     .replace(/"[^"\n]*\s[^"\n]*"|`[^`\n]*\s[^`\n]*`|\u201c[^\u201d\n]*\u201d/g, ' ')
     .replace(/\b(?:neu\s+(?:phai|can|thieu|khong du|bang chung chua du)|if\s+(?:needed|necessary|required|evidence is insufficient))\b[^.;\n]*/g, ' ')
     .replace(/[^.;\n]*\b(?:nao|gi|sao|the nao|bao nhieu)\b[^.;\n]*\?/g, ' ')
-    .replace(/\bchinh\s+xac\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b/g, ' ')
+    .replace(/\bchinh\s+(?:xac|sach)\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b|\b(?:diem|cho|muc|phan)\s+(?:phai|can|nen)\s+(?:sua|fix)\b/g, ' ')
     .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
     .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
     .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ');
 }
 
+// Explicit scope declaration (intent ownership): when the request itself declares it is read-only
+// ("READ-ONLY audit", "chi doc", "make no source changes") and carries no explicit order to change
+// anything, verbs and operation names inside it are descriptions (a "git stash" that already ran, "a
+// worklog edit", "confirmed fixes"), not orders - so they must not demand write or operation proof.
+// An explicit order (imperative-initial or modal request) keeps the request MIXED/IMPLEMENTATION:
+// the declaration never overrides a real instruction, and fenced/quoted/blockquoted text is never one.
+// A bare verb with no object is the tail of a negated list ("no commit, release, publish"), not an order.
+const READ_ONLY_DECLARATION = /\bread[\s-]*only\s+(?:audit|investigation|review|analysis|inspection|task|request|session|pass|check|diagnos\w+|verification|forensics?)\b|(?:^|\n)[\s*#>_-]*read[\s-]*only\s*[.:!—-]|\b(?:audit|investigation|review|analysis)[\s-]*only\b|[(,]\s*read[\s-]*only\s*[).]|\bchi\s+(?:doc|audit|kiem tra|phan tich|dieu tra)\b|\b(?:make|with)\s+no\s+(?:source\s+|code\s+|file\s+)?(?:changes|edits|modifications)\b/;
+const ORDER_VERBS = 'implement|fix|apply|refactor|modify|edit|write|update|add|create|build|install|deploy|redeploy|restart|push|commit|rename|remove|delete|replace|change|sua|viet|chinh|them|tao|xoa|enable|disable|set|toggle|configure|migrate|upgrade|publish|release|trien khai|khoi dong lai|(?:run|execute)\\s+(?:git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)|(?:npm|yarn)\\s+publish)|git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)';
+const IMPERATIVE_ORDER = new RegExp(`^(?:[-*+\\u2022>\\d.)\\s]*)(?:(?:please|hay|vui long|now|also|first|then)\\s+)*(?:${ORDER_VERBS})\\b\\s+\\S`);
+const MODAL_ORDER = new RegExp(`\\b(?:please|hay|vui long|need to|needs to|must|should|want(?:\\s+you)? to|toi muon|can phai|yeu cau)\\s+(?:[\\w-]+\\s+){0,2}(?:${ORDER_VERBS})\\b`);
+function hasExplicitOrder(clauses) {
+  return clauses.some((clause) => IMPERATIVE_ORDER.test(clause) || MODAL_ORDER.test(clause));
+}
+function declaredReadOnly(promptText, releasePolicy) {
+  if (releasePolicy) return false;
+  const plain = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  if (!READ_ONLY_DECLARATION.test(plain)) return false;
+  const text = neutralizeNonOrders(plain);
+  const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0])
+    .filter((clause) => !/\b(?:do not|don't|never|khong|dung)\b/.test(clause));
+  return /\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|investigation|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text)
+    && !hasExplicitOrder(clauses);
+}
+
+// Verification-only request. Root cause of a false `write-evidence` block on a "verify / re-run /
+// confirm" prompt: the vocabulary scans counted nouns and compounds ("coordinator fix", "re-run",
+// "template/install", "source change") as mutation orders. Order is structural: a request whose
+// command-position verbs are verification verbs, with no explicit order (hasExplicitOrder) and no
+// change-leading clause, orders no change - it owes verification evidence, not a write.
+const VERIFY_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:verify|re-?run|confirm|validate|double-?check)\b/;
+const CHANGE_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:make|rebuild|redo|rewrite|restore|revert|correct|clean|patch|resolve|ensure|run(?!(?=[^.]*\b(?:tests?|suite|gate|checks?|lint|typecheck|pilot|smoke|e2e|verif\w*|vitest|jest|audit)\b)))\b/;
+export function isVerificationOnlyRequest(promptText) {
+  const plain = String(promptText ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  const clauses = neutralizeNonOrders(plain).split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0]);
+  return clauses.some((clause) => VERIFY_LEAD.test(clause)) && !hasExplicitOrder(clauses)
+    && !clauses.some((clause) => CHANGE_LEAD.test(clause));
+}
+
 export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
   // A named preflight and both explicit branches are required; a failed arbitrary test is not a release policy.
   const releaseText = String(promptText).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
@@ -221,6 +266,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/);
   const actionable = clauses.map((clause) => clause.split(/\bwithout\b/)[0]).filter((clause) => !/\b(?:do not|don't|never|khong|dung)\b/.test(clause)
     && !/^\s*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
+  if (declaredReadOnly(promptText, releasePolicy)) return { taskKind: 'READ_ONLY' };
   const sourceOrder = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause)
     && /\b(?:source|code|logic|scheduler|implementation|ma nguon)\b|\.[cm]?[jt]sx?\b/.test(clause));
   const codeChangeVerb = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
@@ -238,10 +284,15 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // runtime are separate domains with separate proof; a prompt naming both stays a coding
   // task rather than being half-verified. A code-change verb anywhere keeps write evidence.
   const gitOperation = actionable.some((clause) => /\bgit\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)\b|\bpush\s+(?:to\s+)?origin\b/.test(clause));
-  const runtimeOperation = actionable.some((clause) => /\b(?:restart|redeploy|deploy|khoi dong lai|trien khai)\b/.test(clause)
+  // 'trien khai' is Vietnamese for both "deploy" and "implement": it orders a runtime operation only
+  // when it names a runtime target; bare it describes work ("Tier 3 truc tiep trien khai thay Tier 2").
+  // "restart"/"deploy" after a noun modifier ("process restart", "after redeploy") is a scenario, not an order.
+  const runtimeOperation = actionable.some((clause) => /(?<!\b(?:process|crash|hard|soft|graceful|after|upon|during|across|following)\s)\b(?:restart|redeploy|deploy|khoi dong lai|trien khai\s+(?:len\s+)?(?:service|server|production|prod|staging|dich vu|may chu|moi truong))\b/.test(clause)
     && !/\.[cm]?[jt]sx?\b/.test(clause) && !/\bgit\b/.test(clause));
   const nativeDomain = cronOperation ? 'scheduled-job' : gitOperation !== runtimeOperation ? (gitOperation ? 'git-integrity' : 'service-runtime') : null;
   const operation = Boolean(nativeDomain);
+  // A verification-only request orders no change; a concrete operation order (cancel/restart/push) stays operational.
+  if (!releasePolicy && !operation && isVerificationOnlyRequest(promptText)) return { taskKind: 'READ_ONLY', verificationOnly: true };
   // A config MENTION is not a config change: the same clause needs a mutation verb, and a
   // request that also changes source/code is a coding task (config is part of its tests/fixtures).
   const config = !sourceOrder && actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause)
@@ -252,7 +303,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   const mutationWord = /\b(?:implement|fix|refactor|modify|edit|write|update|add|create|build|make|install|deploy|remove|delete|rename|replace|change|sua|viet|chinh|them|tao|xoa|doi|cai|cap nhat)\b/.test(text);
   const statusReport = !mutationWord && !operation && !config
     && /\b(?:check|status|report|show|summari[sz]e|result|results|kiem tra|bao cao|trang thai|ket qua|da len chua)\b/.test(text);
-  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text) || statusReport)
+  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text.replace(/\bread[\s-]*only\b/g, ' ')) || statusReport)
     && !sourceOrder && !codeChangeVerb && !operation && !config;
   const taskKind = operation ? (sourceOrder || (nativeDomain !== 'scheduled-job' && codeChangeVerb) ? 'MIXED' : 'OPERATIONAL')
     : config ? 'CONFIGURATION' : documentation ? 'DOCUMENTATION_OUTPUT' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
@@ -271,5 +322,5 @@ export function applyTaskSemantics(contract, semantic) {
     completionEvidence: semantic.taskKind === 'DOCUMENTATION_OUTPUT' ? ['report-artifact'] : operationOnly ? ['operation-verification']
       : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
         : semantic.taskKind === 'READ_ONLY' && semantic.statusReport ? []
-        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+        : semantic.taskKind === 'READ_ONLY' ? (semantic.verificationOnly || (evidence.length === 1 && evidence[0] === 'verification-evidence') ? ['verification-evidence'] : ['impact-evidence']) : evidence };
 }

package/src/core/metadata.js

@@ -69,6 +69,7 @@ export async function writeInstallMetadata({
   managedRelativePaths = null,
   retainedManagedRelativePaths = [],
   ompConfigOwnership = null,
+  settingsDefaultsMigration = null,
   lockStaleMs,
   lockMaxWaitMs,
 }) {
@@ -138,6 +139,9 @@ export async function writeInstallMetadata({
     // before) — lets uninstall revert only UKit's changes. Kept across runs.
     const ownership = ompConfigOwnership ?? (previousData?.tool === 'ukit' ? previousData.ompConfigOwnership : null);
     if (ownership) metadata.ompConfigOwnership = ownership;
+    // One-time .claude/settings.json defaults migration marker (see diffPlan.js). Kept across runs.
+    const migrationMarker = settingsDefaultsMigration ?? (previousData?.tool === 'ukit' ? previousData.settingsDefaultsMigration : null);
+    if (migrationMarker) metadata.settingsDefaultsMigration = migrationMarker;
 
     await ensureDir(path.dirname(installMetaPath));
     await writeJson(installMetaPath, metadata);

package/src/core/runInstallPipeline.js

@@ -7,7 +7,7 @@ import { detectProjectContext } from '../context/detectProjectContext.js';
 import { detectProviders } from '../context/detectProviders.js';
 import { buildTemplateVariables } from '../render/buildVariables.js';
 import { buildInstallPlan } from './buildPlan.js';
-import { diffInstallPlan } from './diffPlan.js';
+import { diffInstallPlan, SETTINGS_DEFAULTS_MIGRATION_ID } from './diffPlan.js';
 import { applyDiffResults, pruneOldBackups } from './applyPlan.js';
 import { summarizeDiff, toDiffRows } from './report.js';
 import { writeInstallMetadata, writeCliLocator, readInstallMetadata } from './metadata.js';
@@ -439,7 +439,10 @@ export async function runInstallPipeline({
     .some((e) => (typeof e === 'string' ? e : e?.p) === '.omp/config.yml');
   const ompOwnership = installMetaData?.ompConfigOwnership
     ?? (trackedOmpConfig ? { originalText: null, installedText: 'compaction:\n  thresholdTokens: 350000\n' } : null);
-  const diffResults = await diffInstallPlan(plan, { ompOwnership });
+  const trackedSettings = (Array.isArray(installMetaData?.files) ? installMetaData.files : [])
+    .some((e) => (typeof e === 'string' ? e : e?.p) === '.claude/settings.json');
+  const settingsMigration = { pending: trackedSettings && !installMetaData?.settingsDefaultsMigration };
+  const diffResults = await diffInstallPlan(plan, { ompOwnership, settingsMigration });
   const plannedSummary = summarizeDiff(diffResults);
 
   if (!dryRun) {
@@ -464,6 +467,19 @@ export async function runInstallPipeline({
       }
     }
 
+    // One-time settings.json defaults migration: report it explicitly (never silent) and mark it
+    // done once the settings entry was processed, so later user edits are never migrated again.
+    let settingsDefaultsMigration = null;
+    for (const entry of diffResults) {
+      if (!/(^|[\\/])\.claude[\\/]settings\.json$/.test(String(entry.targetPath))) continue;
+      if (!['create', 'update', 'unchanged'].includes(entry.action)) continue;
+      if (entry.action !== 'unchanged' && !writes.some((w) => w.targetPath === entry.targetPath)) continue;
+      settingsDefaultsMigration = SETTINGS_DEFAULTS_MIGRATION_ID;
+      if (entry.settingsDefaultsMigrated?.length) {
+        console.log(`[UKit] .claude/settings.json: migrated old default ${entry.settingsDefaultsMigrated.join(' + ')} to model "opus" (main orchestrator) / effortLevel "medium"; previous file backed up. To pin your own, set it in .claude/settings.local.json (UKit never edits it).`);
+      }
+    }
+
     // SPEC §7 step 9: surface the .omp/config.yml unattended migration result.
     for (const entry of diffResults) {
       const report = entry?.migrationReport;
@@ -546,6 +562,7 @@ export async function runInstallPipeline({
       managedRelativePaths: [...trackedManagedRelativePaths],
       retainedManagedRelativePaths,
       ompConfigOwnership,
+      settingsDefaultsMigration,
     });
 
     // 3.3.0: hooks spawn the CLI (episodes, self-improve) from a GUI-launched

package/src/core/runtimeConfig.js

@@ -442,7 +442,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
     },
     orchestration: {
       enabled: true,
-      orchestratorModel: 'claude-sonnet-5',
+      orchestratorModel: 'claude-opus-5',
       permissionMode: 'unattended',
       // FR-003: eval-subprocess gate for rendered omp approval (tools.approval.eval).
       // Fail-closed: only an explicit user `true` renders `eval: allow`; absent,

package/src/diagnostics/ompStallSnapshot.js

@@ -0,0 +1,199 @@
+// Development-only incident capture: bounded metadata, no session control or payload persistence.
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { spawn } from 'node:child_process';
+
+const ID_PATTERN = /^[\w.:/-]{1,120}$/;
+const id = (value) => typeof value === 'string' && ID_PATTERN.test(value) ? value : null;
+const time = (value) => Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : null;
+
+
+export async function runBoundedProcess(command, args = [], { timeoutMs = 650, maxBuffer = 65536 } = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let timedOut = false;
+    let oversized = false;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const stdout = [];
+    const stderr = [];
+    let timer;
+    const finish = (result) => { if (!settled) { settled = true; clearTimeout(timer); resolve(result); } };
+    let child;
+    try { child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }); }
+    catch (error) { resolve({ ok: false, errorCode: error.code || 'UNKNOWN', stdout: '', stderr: '' }); return; }
+    timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, Math.max(1, timeoutMs));
+    const collect = (chunks, field) => (chunk) => {
+      const next = field === 'stdout' ? stdoutBytes + chunk.length : stderrBytes + chunk.length;
+      if (next + (field === 'stdout' ? stderrBytes : stdoutBytes) > maxBuffer) { oversized = true; child.kill('SIGKILL'); return; }
+      chunks.push(chunk);
+      if (field === 'stdout') stdoutBytes = next; else stderrBytes = next;
+    };
+    child.stdout.on('data', collect(stdout, 'stdout'));
+    child.stderr.on('data', collect(stderr, 'stderr'));
+    child.on('error', (error) => finish({ ok: false, errorCode: error.code || 'UNKNOWN', stdout: '', stderr: '' }));
+    child.on('close', (code) => finish({ ok: !timedOut && !oversized && code === 0,
+      errorCode: timedOut ? 'ETIMEDOUT' : oversized ? 'MAXBUFFER' : code === 0 ? null : 'EXIT_NONZERO',
+      exitCode: code, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') }));
+  });
+}
+
+export async function readBoundedTail(file, { maxBytes = 262144 } = {}) {
+  const cap = Math.max(1, Math.min(1048576, maxBytes));
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NONBLOCK || 0) | (constants.O_NOFOLLOW || 0));
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw new Error('capture requires a regular file');
+    const size = Math.min(cap, stat.size);
+    const buffer = Buffer.alloc(size);
+    const { bytesRead } = await handle.read(buffer, 0, size, Math.max(0, stat.size - size));
+    let text = buffer.subarray(0, bytesRead).toString('utf8');
+    const truncated = stat.size > size;
+    if (truncated) text = text.includes('\n') ? text.slice(text.indexOf('\n') + 1) : '';
+    return { text, bytesRead, truncated, size: stat.size, modifiedAt: stat.mtimeMs };
+  } finally { await handle.close(); }
+}
+
+const operationKinds = ['model', 'tool', 'hook', 'subagent'];
+const activeStates = new Set(['started', 'running', 'pending', 'waiting']);
+const terminalStates = new Set(['completed', 'finished', 'failed', 'stopped', 'cancelled']);
+export function processInventoryCommand(platform) {
+  return platform === 'win32' ? ['tasklist', ['/FO', 'CSV', '/NH']]
+    : ['ps', ['-A', '-o', 'pid=,ppid=,stat=,etime=,comm=']];
+}
+
+export function parseProcessInventory(platform, text) {
+  if (platform === 'win32') return text.split(/\r?\n/).flatMap((line) => {
+    const fields = line.match(/"(?:[^"]|"")*"|[^,]+/g) || [];
+    const name = fields[0]?.replace(/^"|"$/g, '').replace(/""/g, '"');
+    const pid = Number(fields[1]?.replaceAll('"', ''));
+    return Number.isSafeInteger(pid) && pid > 0 ? [{ pid, name: (name || '').split(/[\\/]/).at(-1) }] : [];
+  });
+  return text.split('\n').flatMap((line) => {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(.+)$/);
+    return match ? [{ pid: Number(match[1]), name: match[5].trim().split(/[\\/]/).at(-1) }] : [];
+  });
+}
+
+export function parseOwnerPids(command, text) {
+  const values = command === 'fuser' ? (text.match(/:\s*([^\r\n]+)/g) || []).flatMap((line) => line.slice(line.indexOf(':') + 1).trim().split(/\s+/).map((token) => token.match(/^(\d+)[A-Za-z]*$/)?.[1]).filter(Boolean))
+    : (text.match(/\b\d+\b/g) || []);
+  return [...new Set(values.map(Number).filter((pid) => Number.isSafeInteger(pid) && pid > 0))];
+}
+
+export function classifySessionActivity({ association = 'NOT_OBSERVABLE', summary = null, now = Date.now(), idleMs = 120000 } = {}) {
+  if (summary?.operatorBlock === 'OBSERVED_BLOCK') return 'OPERATOR_BLOCK';
+  if (summary?.sessionState === 'STOPPED') return 'STOPPED';
+  if (association !== 'ACTIVE_OWNER' || !summary) return 'NOT_OBSERVABLE';
+  const progressAge = Number.isFinite(summary.lastProgressAt) ? Math.max(0, now - summary.lastProgressAt) : null;
+  const outputAge = Number.isFinite(summary.lastOutputAt) ? Math.max(0, now - summary.lastOutputAt) : null;
+  const pending = summary.pendingOperations || {};
+  if (progressAge === null) return 'NOT_OBSERVABLE';
+  if (progressAge >= idleMs) return 'SUSPECTED_STALL';
+  if (Object.values(pending).some((items) => Array.isArray(items) && items.length > 0)
+    && Object.entries(pending).some(([kind, items]) => items.length > 0 && summary.operationObservability?.[kind] === 'OBSERVED')) return 'WAITING';
+  if (outputAge !== null && outputAge >= idleMs) return 'NO_OUTPUT';
+  return 'ACTIVE_PROGRESS';
+}
+
+
+export function summarizeSessionTail(text) {
+  const result = { sessionId: null, modelAlias: 'NOT_OBSERVABLE', resolvedRoute: 'NOT_OBSERVABLE', currentTurn: 'NOT_OBSERVABLE', lastCompletedTurn: 'NOT_OBSERVABLE',
+    pendingModelRequest: 'NOT_OBSERVABLE', lastChunk: 'NOT_OBSERVABLE', terminalEvent: 'NOT_OBSERVABLE', pendingTools: [], unmatchedToolCallCandidates: [], pendingSubagent: 'NOT_OBSERVABLE',
+    pendingOperations: { model: [], tool: [], hook: [], subagent: [] }, operationObservability: { model: 'NOT_OBSERVABLE', tool: 'NOT_OBSERVABLE', hook: 'NOT_OBSERVABLE', subagent: 'NOT_OBSERVABLE' },
+    operatorBlock: 'NOT_OBSERVABLE', turnState: 'NOT_OBSERVABLE', sessionState: 'NOT_OBSERVABLE', compaction: 'NOT_OBSERVABLE', stopContinuation: 'NOT_OBSERVABLE',
+    lastProgressAt: 'NOT_OBSERVABLE', lastOutputAt: 'NOT_OBSERVABLE', outputState: 'NOT_OBSERVABLE' };
+  const operations = Object.fromEntries(operationKinds.map((kind) => [kind, new Map()]));
+  const tools = new Map();
+  const observedOperations = new Set();
+  const operatorBlocks = new Map();
+  for (const line of text.split('\n')) {
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    const ts = time(row.timestamp);
+    if (ts) result.lastProgressAt = Date.parse(ts);
+    if (row.type === 'session' && id(row.id)) { result.sessionId = id(row.id); result.sessionIdentityObserved = true; }
+    if (row.type === 'compaction') result.compaction = { timestamp: ts, id: id(row.id), tokensBefore: Number.isFinite(row.tokensBefore) ? row.tokensBefore : null };
+    if (row.type === 'session_end' || row.type === 'session_stopped') result.sessionState = 'STOPPED';
+
+    if (row.type === 'operation' && operationKinds.includes(row.operation) && id(row.id)) {
+      observedOperations.add(row.operation);
+      const state = typeof row.state === 'string' ? row.state.toLowerCase() : '';
+      if (activeStates.has(state)) operations[row.operation].set(row.id, { id: row.id, ...(id(row.name) ? { name: id(row.name) } : {}) });
+      if (terminalStates.has(state)) operations[row.operation].delete(row.id);
+    }
+    const eventState = String(row.state || '').toLowerCase();
+    if (row.type === 'operator_block' || row.operation === 'operator') {
+      const key = id(row.id) || `block-${operatorBlocks.size}`;
+      if (['pending', 'blocked', 'waiting'].includes(eventState)) operatorBlocks.set(key, { id: id(row.id), state: 'BLOCKED' });
+      if (terminalStates.has(eventState) || ['unblocked', 'cleared'].includes(eventState)) operatorBlocks.delete(key);
+    }
+
+    const message = row.message;
+    if (!message) continue;
+    if (message.role === 'toolResult' && id(message.toolCallId)) tools.delete(message.toolCallId);
+    if (message.role !== 'assistant') continue;
+    result.modelAlias = { provider: id(message.provider), model: id(message.model) };
+    if (message.stopReason) {
+      const stopReason = ['stop', 'toolUse', 'error', 'aborted', 'length'].includes(message.stopReason) ? message.stopReason : 'other';
+      result.lastCompletedTurn = { id: id(row.id), timestamp: ts, stopReason };
+      result.terminalEvent = stopReason;
+      result.turnState = message.stopReason === 'aborted' ? 'TURN_ABORTED' : message.stopReason === 'error' ? 'TURN_ERROR' : 'TURN_COMPLETED';
+    }
+    if (Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type === 'toolCall' && id(part.id)) tools.set(part.id, { id: id(part.id), name: id(part.name) });
+        if (part.type === 'text' && ts) {
+          result.lastOutputAt = Date.parse(ts);
+          result.outputState = 'OBSERVED_OUTPUT';
+        }
+      }
+    }
+  }
+  result.unmatchedToolCallCandidates = [...tools.values()].slice(-32);
+  result.pendingOperations = Object.fromEntries(operationKinds.map((kind) => [kind, [...operations[kind].values()].slice(-32)]));
+  result.pendingTools = result.pendingOperations.tool;
+  result.operationObservability = Object.fromEntries(operationKinds.map((kind) => [kind, observedOperations.has(kind) || (kind === 'tool' && tools.size > 0) ? 'OBSERVED' : 'NOT_OBSERVABLE']));
+  result.pendingModelRequest = result.operationObservability.model === 'OBSERVED' ? (result.pendingOperations.model.length ? 'OBSERVED_PENDING_EVENT' : 'NO_PENDING_EVENT_OBSERVED') : 'NOT_OBSERVABLE';
+  result.pendingSubagent = result.operationObservability.subagent === 'OBSERVED' ? (result.pendingOperations.subagent.length ? 'OBSERVED_PENDING_EVENT' : 'NO_PENDING_EVENT_OBSERVED') : 'NOT_OBSERVABLE';
+  result.operatorBlock = operatorBlocks.size ? 'OBSERVED_BLOCK' : 'NOT_OBSERVABLE';
+  return result;
+}
+
+export function associateSessionEvidence({ sessions = [], ownerLocks = {}, processInventory = { state: 'NOT_OBSERVABLE', processes: [] }, logs = [] } = {}) {
+  const sessionCounts = new Map();
+  for (const session of sessions) if (id(session.sessionId)) sessionCounts.set(session.sessionId, (sessionCounts.get(session.sessionId) || 0) + 1);
+  return sessions.map((session) => {
+    const sessionId = id(session.sessionId);
+    const lock = sessionId ? ownerLocks[sessionId] : null;
+    const lockState = lock?.state || 'NOT_OBSERVABLE';
+    const pids = lockState === 'OBSERVED' && Array.isArray(lock.pids) ? [...new Set(lock.pids.filter((pid) => Number.isSafeInteger(pid) && pid > 0))] : [];
+    const uniqueOwnerPid = pids.length === 1 ? pids[0] : null;
+    const duplicateSession = sessionId !== null && sessionCounts.get(sessionId) > 1;
+    const process = uniqueOwnerPid !== null && processInventory.state === 'OBSERVED'
+      ? processInventory.processes.find((entry) => entry.pid === uniqueOwnerPid && /^omp(?:\.exe)?$/i.test(entry.name)) || null : null;
+    const processAssociation = duplicateSession ? 'AMBIGUOUS_TRANSCRIPT' : pids.length > 1 ? 'AMBIGUOUS_OWNER_LOCK'
+      : uniqueOwnerPid === null ? (lockState === 'NOT_OBSERVABLE' ? 'NOT_OBSERVABLE' : 'UNHELD')
+        : processInventory.state !== 'OBSERVED' ? 'NOT_OBSERVABLE' : process ? 'VERIFIED' : 'PID_NOT_FOUND';
+    const ownerPid = duplicateSession ? null : uniqueOwnerPid;
+    const identityVerified = session?.sessionIdentityObserved === true || session?.sourceCoverage?.sessionIdentityObserved === true;
+    const ompLog = ownerPid === null ? null : logs.find((entry) => entry.pid === ownerPid) || null;
+    const logAssociation = ownerPid === null ? 'NOT_OBSERVABLE' : ompLog ? 'VERIFIED' : 'NOT_OBSERVABLE';
+    return { sessionId, transcript: typeof session.transcriptPath === 'string' ? session.transcriptPath.split(/[\\/]/).at(-1) : null,
+      sessionAssociation: identityVerified && processAssociation === 'VERIFIED' && logAssociation === 'VERIFIED' ? 'ACTIVE_OWNER' : 'NOT_OBSERVABLE',
+      ownerLockState: duplicateSession ? 'AMBIGUOUS_TRANSCRIPT' : lockState, ownerPid, processAssociation, logAssociation, identityVerified,
+      process: process ? { pid: process.pid, name: id(process.name) } : null, ompLog };
+  });
+}
+
+export function buildStallSnapshot({ now = Date.now(), lastProgressAt = null, lastOutputAt = null, idleMs = 120000, executionState = 'NOT_OBSERVABLE', ...evidence } = {}) {
+  const age = (ts) => Number.isFinite(ts) ? Math.max(0, now - ts) : null;
+  const progressAgeMs = age(lastProgressAt);
+  const outputAgeMs = age(lastOutputAt);
+  const activity = evidence.activity || (executionState === 'NO_EXECUTION' ? 'NO_EXECUTION'
+    : executionState !== 'EXECUTING' ? 'NOT_OBSERVABLE'
+      : progressAgeMs === null ? 'NOT_OBSERVABLE' : progressAgeMs >= idleMs ? 'NO_OBSERVED_PROGRESS'
+        : outputAgeMs !== null && outputAgeMs >= idleMs ? 'NO_OUTPUT' : 'RECENT_PROGRESS');
+  return { schemaVersion: 1, capturedAt: new Date(now).toISOString(), verdict: 'INSUFFICIENT_EVIDENCE', activity,
+    executionState, progressAgeMs, outputAgeMs, ...evidence };
+}

package/src/index/playbookRegistry.js

@@ -114,6 +114,20 @@ function hasSqlIntent(text) {
 // The SQL ask touches shape/data rather than a read-only query — routes the
 // migration row instead of a feature build.
 const SQL_SCHEMA_RE = /(?<![A-Za-z0-9_])(?:ddl|alter|drop|(?:create|alter|drop|truncate)\s+table|(?:add|drop|rename|change|modify|update|thêm|xóa|xoá|sửa|sua|đổi|doi)\s+(?:a\s+|the\s+|new\s+|một\s+)*(?:column|cột|cot)(?!\s+of\b)|kiểu\s+dữ\s+liệu|kieu\s+du\s+lieu|data\s?type|not\s+null|constraint|migration|migrate)(?![A-Za-z0-9_])/i;
+// Explicit delegation order: the user themself asks for a worker/subagent to implement
+// ("Delegate the implementation to a worker agent", "have a subagent implement it"). That is an
+// opt-in to the orchestrated path (Tier 3 orchestrates, Tier 2 implements, integration verified by
+// the orchestrator), so it lifts the small-feature fast path into feature-implementation. Live omp
+// run: this exact order stayed on small-feature (explicit-local-target fast path, subagents
+// suppressed) and the Tier 3 main implemented nothing of the delegation. Bare mentions of the
+// words ("worker thread", "the delegate pattern") do not match; negated orders ("don't delegate")
+// veto.
+const DELEGATION_ORDER_RE = /\bdelegat(?:e|ing)\b[^.\n]{0,80}?\bto\s+(?:an?\s+|the\s+|your\s+)?(?:[\w-]+\s+){0,2}?(?:worker|sub-?agents?|agents?|implementer)\b|\b(?:use|spawn|dispatch|launch|assign|have|let)\s+(?:an?\s+|the\s+|your\s+)?(?:[\w-]+\s+)?(?:worker|sub-?agents?|implementer)(?:\s+agent)?\s+(?:to|for)\b|(?<![A-Za-z0-9_])giao\s+(?:việc\s+)?cho\s+(?:worker|sub-?agent|agent)/i;
+const DELEGATION_NEGATED_RE = /\b(?:don['’]?t|do\s+not|never|without|avoid|no\s+need\s+to)\s+(?:[\w-]+\s+){0,2}?(?:delegat\w*|(?:use|spawn|dispatch)\s+(?:an?\s+|any\s+)?(?:worker|sub-?agents?))|\bno\s+(?:worker|sub-?agents?|delegation)\b|\b(?:inline|yourself)\s+(?:only|not)\b/i;
+export function hasDelegationOrder(text) {
+  const t = String(text ?? '');
+  return DELEGATION_ORDER_RE.test(t) && !DELEGATION_NEGATED_RE.test(t);
+}
 // Reuse-first ask: "use the existing/core function", "dùng hàm có sẵn",
 // "tái sử dụng" — search for the function before writing a new one.
 const REUSE_FIRST_RE = /(?:\buse\s+(?:the\s+)?(?:existing|core|shared|same|current)\b)|(?:\buse\s+[\w.]+\s+from\s+(?:the\s+)?(?:core|shared|utils?|common|lib)\b)|\b(?:existing|core|shared)\s+(?:function|helper|util(?:ity|ities)?|service|component)\b|\breuse\b|(?<![A-Za-z0-9_])(?:tái\s+sử\s+dụng|tai\s+su\s+dung)|(?<![A-Za-z0-9_])(?:dùng|dung|dựa|dua)\s+(?:vào\s+|vao\s+)?(?:hàm|ham)(?:\s+(?:có\s+sẵn|co\s+san|sẵn\s+có|san\s+co|đã\s+có|da\s+co|cũ|cu))?(?![A-Za-z0-9_])/i;
@@ -174,7 +188,7 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     // contract signals) escalates to feature-implementation. Reference-driven,
     // clone, reuse-first and SQL-schema asks take the same escape: they name a
     // source of truth or a data contract the small path must not gloss over.
-    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && !s.sqlSchemaChange && !s.referenceTarget && !s.cloneIntent && !s.reuseFirst && s.changeVerbOrCreate,
+    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && !s.sqlSchemaChange && !s.referenceTarget && !s.cloneIntent && !s.reuseFirst && !s.delegationOrdered && s.changeVerbOrCreate,
     fastPath: 'small-feature',
   },
   {
@@ -195,7 +209,7 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     // migration row instead of capturing the build lane.
     discriminator: (s) => (
       (s.contractSignal || s.multiSurface || (s.escalated && !s.sqlSchemaChange) || s.wiredShipAsk)
-      || ((s.referenceTarget || s.cloneIntent || s.reuseFirst) && s.defectIdx === -1)
+      || ((s.referenceTarget || s.cloneIntent || s.reuseFirst || s.delegationOrdered) && s.defectIdx === -1)
     ) && !s.disposable && !s.releaseAsk,
   },
   {
@@ -291,7 +305,9 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     lanes: ['local-fix', 'review-release'],
     triggers: [/\bverify\b|\bcheck\b|\bconfirm\b|\bprove\b|\bvalidate\b|\bassert\b/i],
     // the ask IS a check — a check verb leads, or no defect verb exists at all.
-    discriminator: (s) => s.checkFirst || s.defectIdx === -1,
+    // A build/create verb that leads the ask makes the check its closing step ("implement X … then run the
+    // tests and confirm"), not the ask itself — the build row owns it instead of tying into ambiguity.
+    discriminator: (s) => (s.checkFirst || s.defectIdx === -1) && !s.buildLeadsCheck,
   },
   {
     workGroup: 'skill-evaluation',
@@ -409,6 +425,7 @@ async function buildRouteSignals({
   const explanationAsk = explainIdx !== -1 && (firstVerbIdx === -1 || explainIdx < firstVerbIdx);
   const changeRequested = !consultLead && firstVerbIdx !== -1 && (explainIdx === -1 || firstVerbIdx < explainIdx);
   const checkFirst = checkIdx !== -1 && (defectIdx === -1 || checkIdx < defectIdx);
+  const buildLeadsCheck = changeRequested && checkIdx !== -1 && firstVerbIdx !== -1 && firstVerbIdx < checkIdx;
   // C85-019: a QUESTION about a defect is not a defect order. The bug-fix floor
   // demands repro+root-cause receipts — demanding them on a "did it get fixed
   // yet?" turn forces edits nobody asked for (user-reported lock). Question
@@ -440,12 +457,14 @@ async function buildRouteSignals({
     changeRequested,
     questionAsk,
     checkFirst,
+    buildLeadsCheck,
     changeVerbOrCreate: changeIdx !== -1 || createIdx !== -1,
     referenceTarget,
     cloneIntent,
     sqlIntent,
     sqlSchemaChange: sqlIntent && SQL_SCHEMA_RE.test(signalText),
     reuseFirst,
+    delegationOrdered: hasDelegationOrder(signalText) && changeRequested,
     contractSignal: CONTRACT_SIGNAL_RE.test(signalText) || /\boauth\b/i.test(signalText),
     multiSurface: MULTI_SURFACE_RE.test(signalText),
     escalated: Array.isArray(escalationTriggers) && escalationTriggers.length > 0,

package/src/index/taskRouting.js

@@ -895,7 +895,7 @@ function deriveExecutionScores({
   const buildSignal = /\b(build|create|add|implement|feature)\b/.test(raw);
   const debugSignal = intentMode === 'debug-specific' || /\b(root cause|debug|triage|flaky|investigate|why)\b/.test(raw);
   const reviewSignal = intentMode === 'review-specific' || /\b(review|audit|verify|release readiness)\b/.test(raw);
-  const failureSignal = /\b(failing|failed|broken|error|crash|timeout|undefined|exception|eacces|trace)\b/.test(raw);
+  const failureSignal = /\b(failing|failed|broken|error|crash|timeout|undefined|exception|eacces|trace)\b/.test(raw.replace(/\b(?:throw|raise|emit|reject|return|log|show|surface)(?:s|es|ing)?\s+(?:an?\s+|the\s+)?(?:[a-z-]+\s+){0,2}[a-z]*(?:error|exception)s?\b/g, ' '));
   const impactSignal = /\b(map impact|impact|blast radius|all affected|across (?:runtime|templates|helpers|adapters|mirrors)|affected adapters|affected mirrors|inspect impact)\b/.test(raw);
   const boundedEditSignal = /\b(one[- ]line|small|tiny|single|local|guard|log line|loading message|label)\b/.test(raw);
   const implementSignal = /\b(implement|apply|update|modify|add|create|ship|deliver|fix)\b/.test(raw)
@@ -1813,7 +1813,7 @@ function deriveIntentMode({ promptText = '', commandText = '', targetFile = null
   }
 
   if (concreteTask) {
-    if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|timeout)\b/.test(lower)) {
+    if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|timeout)\b/.test(lower.replace(/\b(?:throw|raise|emit|reject|return|log|show|surface)(?:s|es|ing)?\s+(?:an?\s+|the\s+)?(?:[a-z-]+\s+){0,2}[a-z]*(?:error|exception)s?\b/g, ' '))) {
       return 'debug-specific';
     }
     if (/\b(review|audit|diff|pr feedback|code review|kiem tra|soat)\b/.test(raw)) {

package/template_project/.claude/agents/bug-debugger.md

@@ -2,6 +2,7 @@
 name: bug-debugger
 description: "Debugging specialist for reproducible errors, failing tests, and unexpected behavior. Use proactively when investigation will involve noisy logs, stack traces, or a self-contained reproduce-trace-fix-verify loop. Do not use for trivial obvious fixes or broad architecture ideation."
 model: sonnet  # unic-code
+effort: medium
 color: red
 tools: ["Read", "Grep", "Glob", "Bash", "Edit", "TodoWrite"]
 ---

package/template_project/.claude/agents/code-reviewer.md

@@ -2,6 +2,7 @@
 name: code-reviewer
 description: "Independent reviewer for handoff Phase 3 and for spec/plan documents. For code (default): use after executor reports STATUS: DONE on a handoff task, MUST run with a model different from the executor (configured in .ukit/storage/config.json → handoff.reviewer.model, default unic-smart), produces a verdict: APPROVED | APPROVED-WITH-MINOR | CHANGES-REQUESTED | CRITICAL. For spec/plan documents (set REVIEW_TARGET_TYPE=spec or plan): reviews a docs/plans/*.md file for completeness/consistency/clarity/scope/YAGNI, produces Status: Approved | Issues Found."
 model: opus  # unic-smart
+effort: medium
 color: yellow
 tools: ["Read", "Grep", "Glob", "Bash"]
 ---

package/template_project/.claude/agents/feature-implementer.md

@@ -2,6 +2,7 @@
 name: feature-implementer
 description: "Implementation specialist for clear, self-contained coding tasks. Use proactively when the approach is clear and the work can be completed in a bounded pass with a concise summary. Do not use for trivial one-file tweaks or tightly coupled exploratory work."
 model: sonnet  # unic-code
+effort: medium
 color: green
 tools: ["Read", "Edit", "Write", "Grep", "Glob", "Bash", "TodoWrite"]
 ---

package/template_project/.claude/agents/handoff-planner.md

@@ -2,6 +2,7 @@
 name: handoff-planner
 description: "Handoff planning specialist for Phase 1+2. Use when creating a new handoff cycle: writes PLAN.md with full test plan, splits into TASK-xxx.md files with TDD-embedded test cases, and updates INDEX.md. Always use the strongest available model (Opus/unic-smart)."
 model: opus  # unic-smart
+effort: medium
 color: purple
 tools: ["Read", "Edit", "Write", "Glob", "Bash", "TodoWrite"]
 ---

package/template_project/.claude/agents/ukit-small-task-maintainer.md

@@ -2,6 +2,7 @@
 name: ukit-small-task-maintainer
 description: "Internal UKit maintenance subagent for low-risk, reversible UKit decisions. Use proactively when UKit needs to decide or perform safe cleanup such as pruning docs/TASKS.md, classifying queued work, choosing whether compact/summarization is appropriate, summarizing local docs/status, or maintaining small UKit runtime queues. Do not use for product implementation, security, release/publish, data-loss, architecture, or risky/shared code changes."
 model: haiku  # unic-lite
+effort: low
 color: cyan
 tools: ["Read", "Grep", "Glob", "Edit", "Write"]
 ---

package/template_project/.claude/hooks/completion-gate.sh

@@ -85,7 +85,7 @@ fi
 # (coordinator deadline + margin); a forced kill lands on the existing crash-streak
 # path (non-zero STATUS) so the outcome is announced, never silently released.
 __ukit_coord_out="$(mktemp "${TMPDIR:-/tmp}/ukit-coord-out.XXXXXX")"
-printf '%s' "$INPUT" | UKIT_HARNESS=claude-code UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-3000}" node "$SCRIPT" --evaluate-stop > "$__ukit_coord_out" 2>/dev/null &
+printf '%s' "$INPUT" | UKIT_HARNESS="${UKIT_HARNESS:-claude-code}" UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-3000}" node "$SCRIPT" --evaluate-stop > "$__ukit_coord_out" 2>/dev/null &
 __ukit_coord_pid=$!
 __ukit_coord_ms="${UKIT_HOOK_DEADLINE_MS:-3000}"
 case "$__ukit_coord_ms" in ''|*[!0-9]*) __ukit_coord_ms=3000 ;; esac