@ngockhoale/ukit 3.4.46 → 3.4.48

package/template_project/.claude/settings.json

@@ -1,9 +1,9 @@
 {
-  "model": "sonnet",
+  "model": "opus",
   "fastMode": false,
   "fastModePerSessionOptIn": false,
   "alwaysThinkingEnabled": true,
-  "effortLevel": "high",
+  "effortLevel": "medium",
   "includeGitInstructions": false,
   "promptSuggestionEnabled": false,
   "showThinkingSummaries": false,
@@ -74,8 +74,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/stale-spec-guard.sh\":11 \"$CLAUDE_PROJECT_DIR/.claude/hooks/pre-edit-backup.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-router.sh\":20 \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/context-hardcap-gate.sh\":8",
-            "timeout": 73
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/stale-spec-guard.sh\":11 \"$CLAUDE_PROJECT_DIR/.claude/hooks/pre-edit-backup.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-router.sh\":20 \"$CLAUDE_PROJECT_DIR/.claude/hooks/delegation-gate.mjs\":10 \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/context-hardcap-gate.sh\":8",
+            "timeout": 83
           }
         ]
       },
@@ -84,8 +84,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8",
-            "timeout": 18
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/delegation-gate.mjs\":10 \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8",
+            "timeout": 28
           }
         ]
       },
@@ -94,8 +94,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/auto-allow-bash.sh\":15 \"$CLAUDE_PROJECT_DIR/.claude/hooks/block-dangerous.mjs\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/sensitive-data-guard.mjs\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/context-hardcap-gate.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/verification-guard.sh\":8",
-            "timeout": 65
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/auto-allow-bash.sh\":15 \"$CLAUDE_PROJECT_DIR/.claude/hooks/block-dangerous.mjs\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/sensitive-data-guard.mjs\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/delegation-gate.mjs\":10 \"$CLAUDE_PROJECT_DIR/.claude/hooks/handoff-model-guard.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/context-hardcap-gate.sh\":8 \"$CLAUDE_PROJECT_DIR/.claude/hooks/verification-guard.sh\":8",
+            "timeout": 75
           }
         ]
       }

package/template_project/.claude/ukit/index/playbook-registry.mjs

@@ -113,6 +113,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;
@@ -173,7 +187,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',
   },
   {
@@ -194,7 +208,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,
   },
   {
@@ -290,7 +304,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',
@@ -408,6 +424,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
@@ -439,12 +456,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/template_project/.claude/ukit/index/route-resolver.mjs

@@ -249,36 +249,39 @@ export function buildExecutionContract(executionMode = null) {
 // base row; resolveModelTier adds the (riskFloor, hostCapabilities) columns.
 // Deterministic — no registry, no leases, no outbound capability calls.
 // Literal mirror of src/core/executionContracts.js resolveModelTier.
-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 = buildExecutionContract(executionMode)?.modelTier ?? 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),
   };
 }
@@ -1100,12 +1103,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();
@@ -1117,6 +1163,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));
@@ -1134,10 +1181,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)
@@ -1148,7 +1200,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 || codeChangeVerb ? 'MIXED' : 'OPERATIONAL')
     : config ? 'CONFIGURATION' : documentation ? 'DOCUMENTATION_OUTPUT' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
@@ -1170,5 +1222,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/template_project/.claude/ukit/index/route-task.mjs

@@ -17,6 +17,9 @@ import {
   writeRecentCacheEntry,
 } from './cache-utils.mjs';
 import { ROUTE_CATALOG } from './route-catalog.mjs';
+import { buildTierLane, classifyModelTier, resolveMainTier } from './tier-lane.mjs';
+// Public surface unchanged for tests and callers that import the lane helpers from the route CLI.
+export { buildTierLane, classifyModelTier, resolveMainTier };
 import { detectUnicGateway } from './unic-gateway.mjs';
 import { withAsyncLock } from '../runtime/async-lock.mjs';
 import { appendDecisionReceipt, recordLedgerEvent } from '../runtime/execution-ledger.mjs';
@@ -1068,6 +1071,7 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
     recentOutputSnapshot,
     previousRouteSummary: normalizedInput.previousRouteSummary ?? null,
     escalationConfig,
+    sessionId: normalizedInput.sessionId ?? null,
     // BL-018: caller-injected seams — the in-process entry accepts a prior
     // emission (exhaustion check) and a stubbed decision/registrar for tests.
     escalationDecision: normalizedInput.escalationDecision ?? null,
@@ -1109,6 +1113,40 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
 
 export { DEFAULT_ROUTE_DEADLINE_MS, DEFAULT_ROUTE_IO_BUDGET };
 
+const TASK_INSTANCE_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/;
+// The prompt hook owns turn boundaries: every real user turn writes a fresh state (new id) with one of
+// these sources before the model can run this CLI. A CLI-only environment (Codex: "invoked by
+// instruction") has no such boundary, so there an identical prompt is a REPEATED request and mints a new id.
+const HOOK_STATE_SOURCES = ['skill-router', 'skill-router-provisional'];
+
+// @decision-point task.instance-id-ownership — deterministic reuse-vs-mint ownership decision (the
+// task boundary every evidence receipt is filtered by); regression: tests/index/taskIdentityContinuity.test.js.
+/**
+ * Same task => same id; genuinely new task => fresh id. Returns { id, origin }.
+ *
+ * An id is reused only from a previous state (already session-filtered by main()) that provably belongs
+ * to the SAME hook-owned turn: it was written by the hook, or by this CLI refreshing that hook turn
+ * (taskIdOrigin 'hook'), AND the prompt is identical (or the refresh is prompt-less: tool command / target
+ * only, routed from the stored explicit prompt). The origin ends at a continue phrase, a different prompt,
+ * or any state the hook did not own, so a repeated request still mints a new id and unrelated evidence
+ * stays rejected. An explicit --task-instance-id is honored when well-formed.
+ */
+export function reuseOrMintTaskInstanceId({ previousState = {}, promptText = '', commandText = '', targetFile = null, explicitId = null, continuingTask = false } = {}) {
+  const explicit = typeof explicitId === 'string' ? explicitId.trim() : '';
+  if (explicit && TASK_INSTANCE_ID_SHAPE.test(explicit)) return { id: explicit, origin: null };
+  const prevId = previousState?.taskInstanceId;
+  if (prevId) {
+    const hookTurn = HOOK_STATE_SOURCES.includes(previousState.source)
+      || (previousState.source === 'task-route' && previousState.taskIdOrigin === 'hook');
+    const stored = previousState.routingContext?.lastExplicitUserPromptText;
+    const samePrompt = Boolean(stored) && stored === promptText;
+    const promptlessRefresh = Boolean(stored) && !promptText && Boolean(commandText || targetFile);
+    if (hookTurn && (samePrompt || promptlessRefresh)) return { id: prevId, origin: 'hook' };
+    if (continuingTask) return { id: prevId, origin: null };
+  }
+  return { id: `task-${crypto.randomBytes(16).toString('hex')}`, origin: null };
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const rootDir = getRootDir(args);
@@ -1169,11 +1207,14 @@ async function main() {
   const continuingTask = Boolean(previousState.taskInstanceId && lastPrompt
     && /^(?:continue|resume|keep going|go on|proceed|tiep tuc|lam tiep)(?:\s+(?:with\s+)?(?:the\s+|this\s+)?(?:previous\s+|last\s+|current\s+|same\s+)?(?:implementation\s+)?(?:task|work))?(?:\s+(?:thoi|di|đi|nhe|nao|nua|a|ha|please|pls|now|then))*\s*[.!]?$/i.test(
       promptText.normalize('NFD').replace(/[̀-ͯ]/g, '').trim()));
-  const taskInstanceId = readFlagValue(args, '--task-instance-id')
-    || (((['skill-router', 'skill-router-provisional'].includes(previousState.source)
-      && previousState.routingContext?.lastExplicitUserPromptText === promptText) || continuingTask)
-      && previousState.taskInstanceId
-      ? previousState.taskInstanceId : `task-${crypto.randomBytes(16).toString('hex')}`);
+  const { id: taskInstanceId, origin: taskIdOrigin } = reuseOrMintTaskInstanceId({
+    previousState,
+    promptText,
+    commandText,
+    targetFile,
+    explicitId: readFlagValue(args, '--task-instance-id'),
+    continuingTask,
+  });
   if (continuingTask) promptText = lastPrompt;
   const preparedRoute = await prepareTaskRoute({
     rootDir,
@@ -1269,7 +1310,7 @@ async function main() {
         historySignals,
       };
     }
-    const sharedState = { ...reusableState, taskInstanceId, source: 'task-route', ts: Date.now() };
+    const sharedState = { ...reusableState, taskInstanceId, taskIdOrigin, source: 'task-route', ts: Date.now() };
     if (canPersistRouteState) {
       try { await persistSharedRouteState(sharedStatePath, sharedState); }
       catch (error) { console.error(`route-task: state persist degraded — ${error?.message ?? error}`); }
@@ -1324,6 +1365,8 @@ async function main() {
       applyEscalationToRouteSummary(rescuedRouteSummary, {
         config: escalationConfig,
         targetFile: cachedRouteState.routingContext?.targetFile ?? null,
+        rootDir: rootDir,
+        sessionId,
       });
       // BL-018: re-run the fix-loop transition on the rescued summary — a
       // refreshed fixLoopCount may trip, escalate, or exhaust (BLOCKED); the
@@ -1357,6 +1400,7 @@ async function main() {
     const sharedState = {
       ...cachedRouteState,
       taskInstanceId,
+      taskIdOrigin,
       ...(sessionId ? { sessionId } : {}),
       source: 'task-route',
       ts: Date.now(),
@@ -1420,6 +1464,7 @@ async function main() {
     sessionId,
     taskInstanceId,
   });
+  if (taskIdOrigin) sharedState.taskIdOrigin = taskIdOrigin;
   if (canPersistRouteState) {
     // Advisory persistence — an EACCES/ENOSPC under the lock must never lose
     // the printed route; degrade to stderr and print anyway.
@@ -2504,6 +2549,8 @@ async function finalizeTaskRoute({
   applyEscalationToRouteSummary(routeSummary, {
     config: escalationConfig,
     targetFile: routingContext.targetFile ?? null,
+    rootDir: absoluteRoot,
+    sessionId,
   });
   // BL-018 (SPEC FR-006): fix-loop escalation. historySignals.fixLoopCount is
   // fingerprint-joined (same routeFingerprint/requestKey, never session-wide);
@@ -2694,6 +2741,9 @@ function printRouteState(state) {
   }
   if (state.routeSummary?.tierLane?.instruction) {
     console.log(`tierLane: ${state.routeSummary.tierLane.instruction}`);
+    if (state.routeSummary.tierLane.delegationRequired === true && state.taskInstanceId) {
+      console.log(`handback: start each worker prompt with "[ukit-task ${state.taskInstanceId}]" so its result binds to this task`);
+    }
   }
   if (state.routeSummary?.escalatedTier) {
     console.log(`escalatedTier: ${state.routeSummary.escalatedTier}`);
@@ -3182,7 +3232,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)) {
@@ -4186,7 +4236,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)
@@ -5026,10 +5076,16 @@ function resolveEscalationSettings(config = null) {
  * Escalates exactly one rung above `modelTier` on `tierOrder`, capped at `cap`. Returns null when
  * escalation is disabled, `repeatCount` hasn't reached `debugLoopThreshold`, or `modelTier` isn't
  * on the cost ladder (e.g. no contract selected). Never returns 'vision'.
- * FR-005: when `riskEscalation.level === 'high'` the repeat-count threshold is treated as
- * satisfied (immediate one-rung escalation) and the effective cap rises to 'smart', overriding
- * the configured cap; the reason is prefixed `risk-floor:` so consumers can tell risk-driven
- * escalation from repeat-count escalation.
+ * FR-005: `riskEscalation` (level 'high') is the Stop-gate carrier and has two kinds of evidence with
+ * different meaning here:
+ *  - `stuck-risk` (verified failure evidence): the repeat-count threshold is treated as satisfied
+ *    (immediate one-rung escalation) and the effective cap rises to 'smart', overriding the
+ *    configured cap. This is a capability escalation, so it also counts as complexity evidence.
+ *  - `risk-floor` only (the task touches something dangerous): risk raises verification rigor, not the
+ *    model tier. It lifts a Tier 1 chore to the Tier 2 executor at most, so a code lane is never
+ *    relabelled smart and the Tier 3 orchestrator is never turned into the implementation worker.
+ * The reason is prefixed `stuck-risk:` / `risk-floor:` so consumers can tell the kinds apart from
+ * repeat-count escalation. `complexityEvidence` is the only input that may ask for High effort.
  */
 function computeEscalation({
   modelTier = null,
@@ -5042,8 +5098,11 @@ function computeEscalation({
     return null;
   }
   const settings = resolveEscalationSettings(config);
-  const riskDriven = riskEscalation?.level === 'high';
-  if (!settings.enabled || (!riskDriven && (!Number.isFinite(repeatCount) || repeatCount < settings.debugLoopThreshold))) {
+  const riskHigh = riskEscalation?.level === 'high';
+  const stuckDriven = riskHigh && (riskEscalation.sources ?? []).includes('stuck-risk');
+  const floorDriven = riskHigh && !stuckDriven;
+  const repeatDriven = Number.isFinite(repeatCount) && repeatCount >= settings.debugLoopThreshold;
+  if (!settings.enabled || (!stuckDriven && !floorDriven && !repeatDriven)) {
     return null;
   }
   const currentIndex = settings.tierOrder.indexOf(modelTier);
@@ -5052,22 +5111,30 @@ function computeEscalation({
   }
   const capIndex = settings.tierOrder.indexOf(settings.cap);
   const smartIndex = settings.tierOrder.indexOf('smart');
-  const effectiveCapIndex = riskDriven
+  const codeIndex = settings.tierOrder.indexOf('code');
+  let effectiveCapIndex = stuckDriven
     ? (smartIndex === -1 ? settings.tierOrder.length - 1 : smartIndex)
     : (capIndex === -1 ? settings.tierOrder.length - 1 : capIndex);
+  if (floorDriven && !repeatDriven && codeIndex !== -1) {
+    effectiveCapIndex = Math.min(effectiveCapIndex, codeIndex);
+  }
   const escalatedIndex = Math.min(currentIndex + 1, effectiveCapIndex);
+  if (floorDriven && !repeatDriven && escalatedIndex <= currentIndex) {
+    return null;
+  }
   const escalatedTier = settings.tierOrder[escalatedIndex];
 
   return {
     escalatedTier,
-    escalationReason: riskDriven
-      ? `risk-floor: level=${riskEscalation.level} sources=${(riskEscalation.sources ?? []).join(',')} file=${targetFile ?? 'null'}`
+    complexityEvidence: stuckDriven || repeatDriven,
+    escalationReason: stuckDriven || floorDriven
+      ? `${stuckDriven ? 'stuck-risk' : 'risk-floor'}: level=${riskEscalation.level} sources=${(riskEscalation.sources ?? []).join(',')} file=${targetFile ?? 'null'}`
       : `repeat-count=${repeatCount} threshold=${settings.debugLoopThreshold} file=${targetFile ?? 'null'}`,
   };
 }
 
 /** Attaches escalatedTier/escalationReason to routeSummary, additive alongside modelTier. */
-export function applyEscalationToRouteSummary(routeSummary = null, { config = null, targetFile = null } = {}) {
+export function applyEscalationToRouteSummary(routeSummary = null, { config = null, targetFile = null, rootDir = null, sessionId = null } = {}) {
   if (!routeSummary || typeof routeSummary !== 'object') {
     return routeSummary;
   }
@@ -5089,9 +5156,17 @@ export function applyEscalationToRouteSummary(routeSummary = null, { config = nu
   }
   // Recomputed here (not only in buildRouteSummary) so the lane always reflects the final
   // tier after escalation, on every path that emits a route summary.
+  const mainTier = resolveMainTier({ rootDir, config, sessionId: sessionId ?? null });
   routeSummary.tierLane = buildTierLane({
     modelTier: routeSummary.executionContract?.modelTier ?? null,
     escalatedTier: escalation?.escalatedTier ?? null,
+    mainTier: mainTier.tier,
+    mainTierSource: mainTier.source,
+    delegationPolicy: routeSummary.executionContract?.delegationPolicy ?? null,
+    executionMode: routeSummary.executionMode ?? null,
+    complexityHigh: escalation?.complexityEvidence === true,
+    riskHigh: routeSummary.riskFloor?.floor === 'high-risk',
+    playbookId: routeSummary.playbookId ?? null,
   });
 
   return routeSummary;
@@ -5156,25 +5231,6 @@ function appendRiskEscalationSegment(routeSummary = null) {
   return routeSummary;
 }
 
-// WS-E tier-role wiring: a contract tier only takes effect when the executing session hands
-// the work to an agent whose definition binds that tier — otherwise every session behaves as
-// if it only had one model. `code` is the DEFAULT implementation lane, so a code-tier contract
-// produces no instruction (inline execution on a code session is already correct, and silence
-// keeps the hook flow smooth). Labels are stable tier roles (lite/code/smart), never provider
-// or model identity. Vision never appears here — it is a capability lane, not a cost tier.
-function buildTierLane({ modelTier = null, escalatedTier = null } = {}) {
-  const tier = escalatedTier ?? modelTier;
-  if (!tier || tier === 'vision') {
-    return null;
-  }
-  return {
-    tier,
-    defaultLane: tier === 'code',
-    instruction: tier === 'code'
-      ? null
-      : `Hand this task to an agent bound to the ${tier} tier instead of doing it inline, unless this session already runs on the ${tier} tier.`,
-  };
-}
 
 function advanceContinuationState(continuationState = null, previousContinuationState = null, thresholds = null) {
   if (!continuationState || typeof continuationState !== 'object') {
@@ -6028,6 +6084,27 @@ function shouldIncludeRecentOutput({
   return true;
 }
 
+// Orchestration telemetry for the audit row: what the route REQUESTED (tier lane / effort) next to
+// what the host evidences. Effective values are never inferred from an alias — the only host
+// evidence available to a hook child is the CLAUDE_EFFORT env; the model stays UNKNOWN.
+// skill-router.sh builds the same object (audit row parity).
+export function buildOrchestrationAudit(routeSummary = null, env = process.env) {
+  const lane = routeSummary?.tierLane;
+  if (!lane || typeof lane !== 'object') {
+    return null;
+  }
+  return {
+    mainTier: lane.mainTier ?? null,
+    mainTierSource: lane.mainTierSource ?? null,
+    requestedTier: lane.tier ?? null,
+    lane: lane.instruction ? (lane.mainTier === 'smart' ? 'dispatch-worker' : 'handoff') : 'inline',
+    requestedEffort: lane.effort ?? null,
+    effortBinding: lane.effortBinding ?? null,
+    effectiveEffort: env?.CLAUDE_EFFORT || 'UNKNOWN',
+    effectiveModel: 'UNKNOWN',
+  };
+}
+
 function buildRouteAuditEntry({ route = null, state = null } = {}) {
   const routingContext = route?.routingContext ?? state?.routingContext ?? {};
   const routeSummary = route?.routeSummary ?? state?.routeSummary ?? {};
@@ -6086,6 +6163,7 @@ function buildRouteAuditEntry({ route = null, state = null } = {}) {
     // BL-013: bounded history counters on the audit row — same struct as the
     // route record, identical to the hook's audit emission.
     historySignals: routeSummary?.historySignals ?? null,
+    orchestration: buildOrchestrationAudit(routeSummary),
   };
 }