@ngockhoale/ukit 3.4.30 → 3.4.32

package/CHANGELOG.md

@@ -9,6 +9,29 @@ All notable changes to UKit are documented here.
 - New `/ukit:ci-check` command + `ci-check.mjs` helper (core pack): prechecks, fail-closed budget guard, local preflight, at most one dispatch per invocation, write-ahead run-id state, `status` (never dispatches), `--ref`, `--dry-run`, per-OS report. Never pushes, merges or publishes.
 - Default-branch bootstrap stub documented in `docs/design/CI-CROSS-PLATFORM-MATRIX.md` (requires separate approval).
 
+## 3.4.32 - 2026-10-11
+
+**UNIC-Decision integration P1: safety floors, ordinal score contract, request caps.** Verified with the full suite (566 files) and `yarn release:verify`; no live inference was run (offline fixtures plus an offline run of the Laya server translator).
+- **Sidecar is deterministic-only.** The six `workflow.*` sidecar decisions always return the deterministic answer at every stage; no adapter call is made. `modelAnswer`/`agreement` are no longer emitted; `--fixture`, `--list` and the result schema keys are unchanged.
+- **Escalation floors.** Fix-loop escalation never lowers verification depth (depth = max(deterministic floor, model), order `none<runnable<review-round<escalate`), never swaps the lane, and never applies model output at `shadow`. Fixed in both the template and the live `src/index/fixLoopEscalation.js`.
+- **Review safety floor.** The verdict floor always runs over all findings: critical → `CHANGES-REQUESTED`; important/unknown → at least `APPROVED-WITH-MINOR`; `Act on` buckets cannot be downgraded; `shadow` keeps the deterministic verdict.
+- **Score contract.** Ordinal `score` questions are sent as a string enum of ordered labels (rubric in the function description) and decoded as `indexOf(label)+1`; numeric answers are rejected. Wire format of `route.rigor.v1`/`preflight.rigor.v1` is now labels (`r0`..`r4`); parsed values stay integer 1..N.
+- **Request caps.** `decisionPlane.maxBatchQuestions` (default 8) and `maxEnumLabels` (default 11) are enforced before transport (`unsupported`, deterministic fallback); duplicate question keys are `invalid`. Route shadow and review use partial coverage in ONE batch: skipped decisions are reported (`coverage`, `skippedDecisions`, `outcomeClass: partial`) and keep deterministic results; no request splitting.
+- Limits: oversize requests outside route shadow/review fall back deterministically; escalation lane model answers are never applied; the server-side `unic-decision` model alias is unchanged. Details: `docs/UNIC-DECISION-INTEGRATION-P1-FIX.md`.
+
+## 3.4.31 - 2026-10-11
+
+**Completion Gate: task-aware operational completion (fixes the CronDelete/CronList false positive).** Verified with the full suite (`yarn test`, 566 files) plus focused six-scenario routing → recorder → Stop regressions.
+- **Task kinds.** CODE_IMPLEMENTATION / OPERATIONAL / READ_ONLY / CONFIGURATION / MIXED are classified independently of write activity. Implementation still requires a source write plus risk-based verification; mixed tasks keep both obligations.
+- **Operational evidence.** New bounded, tool-agnostic proof bank (`operation-evidence.mjs`) and strict native-result normalization (`cron-operation-adapter.mjs`): completion needs an accepted execution, matching target/scope, a fresh verified postcondition and active-task evidence. Unsupported result shapes fail closed.
+- **Task-instance isolation.** Each request gets its own task identity; identical repeated requests are distinct tasks, while continue/resume keeps identity. Evidence and journals from an earlier task cannot satisfy a new one.
+- **Receipt retention / replay protection.** Failed operations survive receipt eviction; native tool-use IDs are tracked (bounded, fail-closed on saturation) so an overwritten observation cannot replay as fresh proof.
+- **Claude Code / OMP.** The Claude recorder and settings matchers cover `CronDelete`/`CronList` success and failure events; the OMP bridge normalizes `cron_delete`/`cron_list` results. Codex uses the shared policy helper (no native Stop enforcement claimed).
+- **Negation-aware classification.** "Xóa cron …, không thay đổi code, Git hoặc Docker" / "Delete cron …. Do not modify source code, Git or Docker." classify as OPERATIONAL; negated source instructions no longer become source requirements.
+- **No-route mutation.** A prompt that ordered a change but matched no skill (no routed contract) now ends with an explicit "nothing was verified" notice instead of a silent stop. This is a notice, not a block — a known limitation.
+- Loop-breaker release note no longer claims no verification ran; docs retry-guidance wording aligned in the template instructions.
+- Limits: classifier is lexical; the Cron adapter does not support an "ensure presence" goal (fails closed); no live native end-to-end run was performed.
+
 ## 3.4.30 - 2026-10-10
 
 **Orchestration: routing, goal/cycle continuation, task ownership, discovery, landing.** Verified with `yarn test:handoff` (184/184) and `yarn release:verify`; live Claude Code two-cycle run-all and the Claude create-only permission denial were exercised on disposable fixtures. Known limits: OMP permission denial is verified through the hook bridge only, and Codex has no pre-tool hook for ownership enforcement. No performance gain is claimed beyond removing the identified redundant Stop-denial / archive-repair round.

package/manifests/documentation.yaml

@@ -933,6 +933,18 @@ entries:
     archive_policy: never
     notes: C69 G7 operator doc — timeline render, support bundle contents/exclusions, replay limits
 
+  - id: docs-unic-decision-integration-p1-fix
+    path: docs/UNIC-DECISION-INTEGRATION-P1-FIX.md
+    class: canonical
+    audience: [maintainer]
+    owner: runtime
+    source_of_truth: docs/UNIC-DECISION-INTEGRATION-P1-FIX.md
+    merge_strategy: none
+    load_policy: on-demand
+    validation: [manual]
+    archive_policy: never
+    notes: P1 safety-floor / ordinal choice score / request-cap fix record for the unic-decision integration (9971eac0)
+
   - id: docs-design-ci-cross-platform-matrix
     path: docs/design/CI-CROSS-PLATFORM-MATRIX.md
     class: canonical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.30",
+  "version": "3.4.32",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/src/core/executionContracts.js

@@ -166,3 +166,35 @@ export function buildConfigContracts() {
     Object.entries(EXECUTION_CONTRACTS).map(([mode, contract]) => [mode, stripContractForConfig(contract)])
   );
 }
+
+// Task semantics are independent of source execution strategy and observed progress.
+export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
+  const text = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').toLowerCase();
+  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));
+  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix|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 operation = actionable.some((clause) => /\b(?:delete|remove|cancel|xoa|huy|ensure|dam bao)\b/.test(clause)
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause));
+  const config = actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause));
+  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
+  const readOnly = /\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text)
+    && !sourceOrder && !operation && !config;
+  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+    : config ? 'CONFIGURATION' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
+  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
+  return { taskKind, ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation ? { operationGoal: { domain: 'scheduled-job', target: id, desiredState: /\b(?:delete|remove|cancel|xoa|huy|absent|removed|deleted|no longer|khong con)\b/.test(actionable.join(' ')) ? 'absent' : 'present',
+      completionSemantics: /\b(?:ensure|dam bao)\b/.test(text) ? 'ensure-state' : 'execute-and-verify' } } : {}) };
+}
+
+export function applyTaskSemantics(contract, semantic) {
+  const evidence = contract?.completionEvidence || [];
+  const operationOnly = semantic.taskKind === 'OPERATIONAL'
+    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
+  return { ...(contract || {}), ...semantic,
+    completionEvidence: operationOnly ? ['operation-verification']
+      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
+        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+}

package/src/decision/client.js

@@ -368,6 +368,21 @@ export function createDecisionClient({
       return outcome('invalid', { fallbackCode: 'empty-batch' });
     }
 
+    const maxBatch = dp.maxBatchQuestions ?? 8;
+    const maxEnum = dp.maxEnumLabels ?? 11;
+    if (![maxBatch, maxEnum].every(n => Number.isInteger(n) && n > 0)) {
+      return outcome('unsupported', { fallbackCode: 'invalid-decision-limits' });
+    }
+    if (questions.length > maxBatch) {
+      return outcome('unsupported', { fallbackCode: 'max-batch-questions' });
+    }
+    if (questions.some(q => Array.isArray(q.candidates) && q.candidates.length > maxEnum)) {
+      return outcome('unsupported', { fallbackCode: 'max-enum-labels' });
+    }
+    if (new Set(questions.map(q => q.decisionKey)).size !== questions.length) {
+      return outcome('invalid', { fallbackCode: 'duplicate-question' });
+    }
+
     // Language classification covers state + question text; the English
     // checkpoint is reachable only when the whole request proves English.
     // Malformed batch input (cyclic state, non-serializable values, internal

package/src/decision/protocol.js

@@ -51,23 +51,20 @@ export function encodeQuestion(question) {
       description: 'true iff the proposition holds; interpreted as P(true).',
     };
   } else {
-    // score — ordinal integer; the legend MUST be defined in the description.
-    const legend = Array.isArray(candidates) ? candidates : [];
-    value = { type: 'integer' };
-    if (legend.length > 0) {
-      value.minimum = 1;
-      value.maximum = legend.length;
-      value.description = `Ordered scale: ${legend
-        .map((label, i) => `${i + 1}=${label}`)
-        .join(', ')}.`;
+    if (!Array.isArray(candidates) || candidates.length === 0
+        || candidates.some(label => typeof label !== 'string' || !label.trim())
+        || new Set(candidates).size !== candidates.length) {
+      throw new TypeError('score requires unique non-empty ordinal labels.');
     }
+    value = { type: 'string', enum: [...candidates] };
   }
 
   return {
     type: 'function',
     function: {
       name: decisionKey,
-      description: String(instruction ?? ''),
+      description: String(instruction ?? '') + (kind === 'score'
+        ? `\nOrdered ordinal rubric: ${candidates.map((label, i) => `${i + 1}=${JSON.stringify(label)}`).join(', ')}. Choose exactly one label; do not return an expected numeric score.` : ''),
       parameters: {
         type: 'object',
         properties: { value },
@@ -184,11 +181,12 @@ function validateValue(question, args) {
     if (isFiniteNumber(value) && value >= 0 && value <= 1) return { value };
     return 'missing-value';
   }
-  // score — finite integer within the declared legend range.
-  if (!isFiniteNumber(value) || !Number.isInteger(value)) return 'missing-value';
+  // Decode an explicit choice losslessly; never reinterpret native expectations.
   const legend = Array.isArray(question.candidates) ? question.candidates : [];
-  if (legend.length > 0 && (value < 1 || value > legend.length)) return 'out-of-enum';
-  return { value };
+  if (!legend.length || new Set(legend).size !== legend.length) return 'out-of-enum';
+  if (typeof value !== 'string') return 'missing-value';
+  const ordinal = legend.indexOf(value);
+  return ordinal < 0 ? 'out-of-enum' : { value: ordinal + 1 };
 }
 
 /**

package/src/decision/reviewVerdict.js

@@ -135,7 +135,7 @@ function stableBatchId(findings) {
  *            findings: object[], verdictDecisionKey: string}}
  *          Never throws — garbage input sanitizes to an empty finding list.
  */
-export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
+export function buildReviewVerdictBatch({ findings = [], mode = 'solo', maxQuestions = Infinity } = {}) {
   const usedIds = new Set();
   // Sanitize the FULL finding set — MAX_FINDINGS is a display/transport bound
   // for the batch, not a verdict bound. The deterministic verdict and the
@@ -145,6 +145,19 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   const batchFindings = sanitized.slice(0, MAX_FINDINGS);
   const truncated = sanitized.length > batchFindings.length;
 
+  // Request-cap handling (no extra call): when verdict + one bucket question per
+  // finding would exceed `maxQuestions`, ask only findings whose bucket the model
+  // can actually change. `Act on` is a deterministic floor the model cannot
+  // lower, so critical/important/unknown findings carry no semantic value in the
+  // batch; the rest keep their deterministic bucket and are reported as skipped.
+  const slots = Number.isInteger(maxQuestions) && maxQuestions > 0
+    ? maxQuestions - 1 : Infinity;
+  const askedFindings = batchFindings.length <= slots
+    ? batchFindings
+    : batchFindings.filter((f) => deriveDeterministicBucket(f) !== 'Act on').slice(0, slots);
+  const askedIds = new Set(askedFindings.map((f) => f.id));
+  const skippedFindingIds = batchFindings.filter((f) => !askedIds.has(f.id)).map((f) => f.id);
+
   const verdictDecisionKey = mode === 'panel'
     ? REVIEW_VERDICT_KEYS.panel
     : REVIEW_VERDICT_KEYS.solo;
@@ -169,7 +182,7 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   // One bucket question per finding. The shared registered key cannot repeat
   // in one batch (name-based reconciliation), so each wire name carries
   // `#<findingId>`; parseVerdictAnswer splits it back off.
-  const bucketQuestions = batchFindings.map((f) => ({
+  const bucketQuestions = askedFindings.map((f) => ({
     decisionKey: `${REVIEW_VERDICT_KEYS.bucket}#${f.id}`,
     schemaVersion: 1,
     family: 'review',
@@ -207,6 +220,7 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
     findings: batchFindings,
     fullFindings: sanitized,
     truncated,
+    skippedFindingIds,
     verdictDecisionKey,
   };
 }

package/src/index/fixLoopEscalation.js

@@ -394,14 +394,20 @@ export async function applyFixLoopEscalation({
     : null;
   // A model lane that refuses to deepen is not an escalation answer — the
   // deterministic deeper lane wins so the loop actually exits its lane.
-  const usableModelLane = modelLane && modelLane !== currentLane ? modelLane : null;
-  const lane = usableModelLane ?? deterministicLane;
+  // Lanes are capabilities, not an ordinal ladder. Without a validated policy
+  // relation only the deterministic destination is admissible.
+  const usableModelLane = planeStage !== 'shadow' && modelLane === deterministicLane
+    ? modelLane : null;
+  const lane = deterministicLane;
   const endpointDown = batchResult !== null
     && batchResult.status !== 'accepted'
     && batchResult.status !== 'partial'
     && !usableModelLane;
-  const depth = (modelDepth && modelDepth !== 'none' ? modelDepth : null)
-    ?? resolveEscalationVerificationDepth({ routeSummary, config });
+  const depthFloor = resolveEscalationVerificationDepth({ routeSummary, config });
+  const depthOrder = ['none', 'runnable', 'review-round', 'escalate'];
+  const depth = planeStage !== 'shadow'
+    && depthOrder.indexOf(modelDepth) > depthOrder.indexOf(depthFloor)
+    ? modelDepth : depthFloor;
 
   const reason = [
     `fix-loop: fixLoopCount=${fixLoopCount} threshold=${settings.debugLoopThreshold} fingerprint-joined`,

package/src/index/routeResolver.js

@@ -509,12 +509,12 @@ function unique(values) {
 
 // Completion contract for a lane. Informational routes carry no completion debt;
 // every contract lane returns the still-missing evidence classes plus a reason.
-export function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
+export function buildCompletionState({ executionMode = null, verificationRecommendation = null, executionContract = null } = {}) {
   if (!executionMode || executionMode === 'informational') {
     return null;
   }
 
-  const contract = buildExecutionContract(executionMode);
+  const contract = executionContract || buildExecutionContract(executionMode);
   const missingEvidence = [...(contract?.completionEvidence ?? [])];
   const requiresVerification = missingEvidence.includes('verification-evidence');
   if (

package/src/index/taskRouting.js

@@ -1,3 +1,4 @@
+import { classifyTaskSemantics, applyTaskSemantics } from '../core/executionContracts.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -669,10 +670,11 @@ export function buildRouteSummary({
     executionScores,
     executionCandidates,
   });
-  const executionContract = buildExecutionContract(executionMode);
+  const executionContract = applyTaskSemantics(buildExecutionContract(executionMode), classifyTaskSemantics({ promptText: routingContext.lastExplicitUserPromptText || routingContext.promptText, targetFile: routingContext.targetFile }));
   const continuousExecution = buildContinuousExecutionPolicy(autonomyLevel);
   const completionState = buildCompletionState({
     executionMode,
+    executionContract,
     verificationRecommendation,
   });
   const continuationState = buildContinuationState({

package/template_project/.claude/hooks/record-execution.mjs

@@ -68,9 +68,7 @@ async function releaseDelegatedClaims(payload, projectRoot) {
 async function record({ rawInput, projectRoot, env, signal, deadlineMs }) {
   const payload = parsePayload(rawInput) ?? {};
   await releaseDelegatedClaims(payload, projectRoot);
-  // A failed delegation never reaches PostToolUse; the claim is already handed back above and
-  // there is no successful receipt to record.
-  if (payload.hook_event_name === 'PostToolUseFailure') return { code: 0, stdout: '', stderr: '' };
+  // Failed native invocations retain their real identity and never mint success evidence.
   const ledgerPath = env.UKIT_EXECUTION_LEDGER_PATH || DEFAULT_LEDGER_PATH;
   let ledger;
   try {

package/template_project/.claude/hooks/skill-router.sh

@@ -1790,6 +1790,39 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     return null;
   }
 
+
+// Task semantics are independent of source execution strategy and observed progress.
+function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
+  const text = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').toLowerCase();
+  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));
+  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix|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 operation = actionable.some((clause) => /\b(?:delete|remove|cancel|xoa|huy|ensure|dam bao)\b/.test(clause)
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause));
+  const config = actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause));
+  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
+  const readOnly = /\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text)
+    && !sourceOrder && !operation && !config;
+  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+    : config ? 'CONFIGURATION' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
+  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
+  return { taskKind, ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation ? { operationGoal: { domain: 'scheduled-job', target: id, desiredState: /\b(?:delete|remove|cancel|xoa|huy|absent|removed|deleted|no longer|khong con)\b/.test(actionable.join(' ')) ? 'absent' : 'present',
+      completionSemantics: /\b(?:ensure|dam bao)\b/.test(text) ? 'ensure-state' : 'execute-and-verify' } } : {}) };
+}
+
+function applyTaskSemantics(contract, semantic) {
+  const evidence = contract?.completionEvidence || [];
+  const operationOnly = semantic.taskKind === 'OPERATIONAL'
+    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
+  return { ...(contract || {}), ...semantic,
+    completionEvidence: operationOnly ? ['operation-verification']
+      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
+        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+}
+
   function buildRouteSummary({
     activeSkills = [],
     routingContext = {},
@@ -1830,9 +1863,10 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       executionScores,
       executionCandidates,
     });
-    const executionContract = buildExecutionContract(executionMode);
+    const executionContract = applyTaskSemantics(buildExecutionContract(executionMode), classifyTaskSemantics({ promptText: routingContext.lastExplicitUserPromptText || routingContext.promptText, targetFile: routingContext.targetFile }));
     const completionState = buildCompletionState({
       executionMode,
+    executionContract,
       verificationRecommendation,
     });
     const continuationState = buildContinuationState({
@@ -2698,12 +2732,12 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     };
   }
 
-  function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
+  function buildCompletionState({ executionMode = null, verificationRecommendation = null, executionContract = null } = {}) {
     if (!executionMode || executionMode === 'informational') {
       return null;
     }
 
-    const contract = buildExecutionContract(executionMode);
+    const contract = executionContract || buildExecutionContract(executionMode);
     const missingEvidence = [...(contract?.completionEvidence ?? [])];
     const requiresVerification = missingEvidence.includes('verification-evidence');
     if (
@@ -3586,6 +3620,34 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
   // after this one overwrites the shared file, and this session's Stop would then see a
   // foreign owner and report its route as lost. Best-effort — the shared write is authoritative.
   async function persistRouteState(text) {
+    const persisted = JSON.parse(text);
+    persisted.taskInstanceId = taskInstanceId;
+    if (continuingTask && previous.routingContext?.lastExplicitUserPromptText) {
+      persisted.routingContext ||= {};
+      persisted.routingContext.lastExplicitUserPromptText = previous.routingContext.lastExplicitUserPromptText;
+    }
+    const semantic = continuingTask && previous.routeSummary?.executionContract?.taskKind
+      ? previous.routeSummary.executionContract
+      : classifyTaskSemantics({ promptText: extractPrompt(payload) || persisted.routingContext?.lastExplicitUserPromptText, targetFile: persisted.routingContext?.targetFile });
+    const informationalTurn = !continuingTask && persisted.routingContext?.executionMode === 'informational'
+      && semantic.taskKind === 'CODE_IMPLEMENTATION';
+    if (informationalTurn) {
+      delete persisted.routeSummary;
+      delete persisted.requestKey;
+    } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary) {
+      persisted.routeSummary ||= { executionMode: 'local-build' };
+      persisted.routeSummary.executionContract = applyTaskSemantics(
+        persisted.routeSummary.executionContract || buildExecutionContract(persisted.routeSummary.executionMode === 'informational' ? 'local-build' : persisted.routeSummary.executionMode), semantic);
+      if (semantic.taskKind === 'OPERATIONAL' || semantic.taskKind === 'READ_ONLY'
+        || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external')) {
+        persisted.routeSummary.completionState = buildCompletionState({
+          executionMode: persisted.routeSummary.executionMode === 'informational' ? 'local-build' : persisted.routeSummary.executionMode,
+          executionContract: persisted.routeSummary.executionContract,
+        });
+        persisted.routeSummary.continuationState = buildContinuationState({ completionState: persisted.routeSummary.completionState });
+      }
+    }
+    text = JSON.stringify(persisted);
     await writeJsonFileAtomic(statePath, text);
     if (!sessionId) return;
     try {
@@ -3602,13 +3664,19 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     } catch {}
   }
   const storedPrevious = await readJson(statePath, {});
-  // Route state is project-local, while hook ledgers are session-local. Do not let a
-  // differently-bound snapshot become the contract for a new session.
+  // The shared slot may belong to another session; recover only our owned sidecar.
+  const sidecarPrevious = sessionId && String(storedPrevious?.sessionId || '').trim() !== sessionId
+    ? await readJson(path.join(projectRoot, '.ukit', 'storage', 'cache', 'route-state', `${sessionId.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96) || 'default'}.json`), {})
+    : {};
   const previous = sessionId
-    ? (storedPrevious?.sessionId && String(storedPrevious.sessionId).trim() === sessionId
-      ? storedPrevious
-      : {})
+    ? [storedPrevious, sidecarPrevious].find((state) => String(state?.sessionId || '').trim() === sessionId) || {}
     : storedPrevious;
+  const continuationPrompt = /^(?:continue|resume|keep going|proceed|tiep tuc)(?:\s+(?:the task|this task|previous task))?[.!]?$/i.test(
+    extractPrompt(payload).normalize('NFD').replace(/[̀-ͯ]/g, '').trim());
+  const continuingTask = Boolean(previous.taskInstanceId && (payload.tool_name || continuationPrompt));
+  const taskInstanceId = continuingTask
+    ? previous.taskInstanceId
+    : `task-${crypto.randomBytes(16).toString("hex")}`;
   const runtimeConfig = await loadRuntimeConfig(projectRoot);
   // BL-013: the hook/bridge payload's transcript pointer (ukit-bridge.js:217,228
   // forwards transcriptPath; Claude Code payloads carry transcript_path). The
@@ -3745,7 +3813,7 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     });
 
     if (
-      previous?.fingerprint === fingerprint
+      payload.tool_name && previous?.fingerprint === fingerprint
       && !previous?.routeSummary
       && Array.isArray(previous?.activeSkills)
       && previous.activeSkills.length === 0
@@ -4084,6 +4152,11 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
   });
 
   if (previous?.fingerprint === fingerprint && now - previousTs < debounceMs) {
+    await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+      routingContext,
+      routeSummary,
+      state: { requestKey, fingerprint, source: 'skill-router' },
+    }));
     process.exit(0);
   }
 

package/template_project/.claude/settings.json

@@ -101,6 +101,16 @@
       }
     ],
     "PostToolUse": [
+      {
+        "matcher": "CronDelete|CronList",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/record-execution.mjs\":8",
+            "timeout": 18
+          }
+        ]
+      },
       {
         "matcher": "Read|Grep|Glob",
         "hooks": [
@@ -142,6 +152,18 @@
         ]
       }
     ],
+    "PostToolUseFailure": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/record-execution.mjs\":8",
+            "timeout": 18
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [

package/template_project/.claude/ukit/index/fix-loop-escalation.mjs

@@ -394,14 +394,20 @@ export async function applyFixLoopEscalation({
     : null;
   // A model lane that refuses to deepen is not an escalation answer — the
   // deterministic deeper lane wins so the loop actually exits its lane.
-  const usableModelLane = modelLane && modelLane !== currentLane ? modelLane : null;
-  const lane = usableModelLane ?? deterministicLane;
+  // Lanes are capabilities, not an ordinal ladder. Without a validated policy
+  // relation only the deterministic destination is admissible.
+  const usableModelLane = planeStage !== 'shadow' && modelLane === deterministicLane
+    ? modelLane : null;
+  const lane = deterministicLane;
   const endpointDown = batchResult !== null
     && batchResult.status !== 'accepted'
     && batchResult.status !== 'partial'
     && !usableModelLane;
-  const depth = (modelDepth && modelDepth !== 'none' ? modelDepth : null)
-    ?? resolveEscalationVerificationDepth({ routeSummary, config });
+  const depthFloor = resolveEscalationVerificationDepth({ routeSummary, config });
+  const depthOrder = ['none', 'runnable', 'review-round', 'escalate'];
+  const depth = planeStage !== 'shadow'
+    && depthOrder.indexOf(modelDepth) > depthOrder.indexOf(depthFloor)
+    ? modelDepth : depthFloor;
 
   const reason = [
     `fix-loop: fixLoopCount=${fixLoopCount} threshold=${settings.debugLoopThreshold} fingerprint-joined`,

package/template_project/.claude/ukit/index/review-verdict.mjs

@@ -146,7 +146,7 @@ function stableBatchId(findings) {
   return `rv-${(h >>> 0).toString(16).padStart(8, '0')}`;
 }
 
-export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
+export function buildReviewVerdictBatch({ findings = [], mode = 'solo', maxQuestions = Infinity } = {}) {
   const usedIds = new Set();
   // Sanitize the FULL finding set — MAX_FINDINGS is a display/transport bound
   // for the batch, not a verdict bound. The deterministic verdict and the
@@ -156,6 +156,19 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
   const batchFindings = sanitized.slice(0, MAX_FINDINGS);
   const truncated = sanitized.length > batchFindings.length;
 
+  // Request-cap handling (no extra call): when verdict + one bucket question per
+  // finding would exceed `maxQuestions`, ask only findings whose bucket the model
+  // can actually change. `Act on` is a deterministic floor the model cannot
+  // lower, so critical/important/unknown findings carry no semantic value in the
+  // batch; the rest keep their deterministic bucket and are reported as skipped.
+  const slots = Number.isInteger(maxQuestions) && maxQuestions > 0
+    ? maxQuestions - 1 : Infinity;
+  const askedFindings = batchFindings.length <= slots
+    ? batchFindings
+    : batchFindings.filter((f) => deriveDeterministicBucket(f) !== 'Act on').slice(0, slots);
+  const askedIds = new Set(askedFindings.map((f) => f.id));
+  const skippedFindingIds = batchFindings.filter((f) => !askedIds.has(f.id)).map((f) => f.id);
+
   const verdictDecisionKey = mode === 'panel'
     ? REVIEW_VERDICT_KEYS.panel
     : REVIEW_VERDICT_KEYS.solo;
@@ -177,7 +190,7 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
     hardConstraintRefs: ['verdict-vocabulary'],
   };
 
-  const bucketQuestions = batchFindings.map((f) => ({
+  const bucketQuestions = askedFindings.map((f) => ({
     decisionKey: `${REVIEW_VERDICT_KEYS.bucket}#${f.id}`,
     schemaVersion: 1,
     family: 'review',
@@ -213,6 +226,7 @@ export function buildReviewVerdictBatch({ findings = [], mode = 'solo' } = {}) {
     findings: batchFindings,
     fullFindings: sanitized,
     truncated,
+    skippedFindingIds,
     verdictDecisionKey,
   };
 }
@@ -362,7 +376,7 @@ function readMergedConfig(rootDir, homeDir) {
 // Deterministic output object. Field order is fixed so the printed JSON is
 // byte-identical for identical findings on the off/failure paths.
 function emitVerdict({ mode, stage, outcomeClass, verdict, verdictStatus,
-  verdictSource, buckets, batchId, fallbackCode }) {
+  verdictSource, buckets, batchId, fallbackCode, coverage }) {
   return {
     schema: 'review-verdict/v1',
     mode,
@@ -374,6 +388,7 @@ function emitVerdict({ mode, stage, outcomeClass, verdict, verdictStatus,
     buckets,
     batchId,
     fallbackCode: fallbackCode ?? null,
+    ...(coverage ? { coverage } : {}),
   };
 }
 
@@ -407,6 +422,25 @@ const VERDICT_SEVERITY_RANK = {
 
 function foldBatchResult(result, built, mode, stage) {
   const folded = parseVerdictAnswer(result, { findings: built.findings });
+  if (stage === 'shadow') {
+    return deterministicResult({ mode, stage, outcomeClass: folded.status,
+      findings: built.findings, batchId: built.batch.batchId,
+      fallbackCode: 'shadow-observation-only',
+      verdictOverride: deriveDeterministicVerdict(built.fullFindings ?? built.findings) });
+  }
+  const skipped = new Set(built.skippedFindingIds ?? []);
+  folded.buckets = folded.buckets.map((bucket, index) => {
+    const floor = deriveDeterministicBucket(built.findings[index]);
+    if (skipped.has(bucket.findingId)) {
+      return { findingId: bucket.findingId, bucket: floor, bucketStatus: 'deterministic:not-asked' };
+    }
+    return floor === 'Act on' && bucket.bucket !== floor
+      ? { ...bucket, bucket: floor, bucketStatus: 'clamp:safety-floor' } : bucket;
+  });
+  const coverage = skipped.size > 0
+    ? { asked: built.findings.length - skipped.size, total: built.findings.length,
+        skippedFindingIds: [...skipped], reason: 'batch-cap', complete: false }
+    : null;
   const modelVerdict = folded.verdict;
   // W3-RV1: the batch may be display-truncated at MAX_FINDINGS — the model
   // verdict was computed on `built.findings` only, so when truncation
@@ -415,28 +449,29 @@ function foldBatchResult(result, built, mode, stage) {
   const fullVerdict = deriveDeterministicVerdict(
     built.fullFindings ?? built.findings,
   );
-  const clamped = built.truncated
-    && modelVerdict !== null
+  const clamped = modelVerdict !== null
     && (VERDICT_SEVERITY_RANK[fullVerdict] ?? 0)
        > (VERDICT_SEVERITY_RANK[modelVerdict] ?? 0);
   // Parse-level classes (accepted/partial/invalid/abstained) pass through;
   // every transport/gateway class surfaces as 'unavailable' — the fallback
   // code carries the finer-grained reason for receipts.
   const PARSE_CLASSES = new Set(['accepted', 'partial', 'invalid', 'abstained']);
-  const outcomeClass = PARSE_CLASSES.has(folded.status) ? folded.status : 'unavailable';
+  let outcomeClass = PARSE_CLASSES.has(folded.status) ? folded.status : 'unavailable';
+  if (coverage && outcomeClass === 'accepted') outcomeClass = 'partial';
   return emitVerdict({
+    coverage,
     mode,
     stage,
     outcomeClass,
     verdict: clamped ? fullVerdict : (modelVerdict ?? fullVerdict),
     verdictStatus: modelVerdict === null
       ? `fallback:${folded.verdictStatus}`
-      : (clamped ? 'clamp:truncated-findings' : folded.verdictStatus),
+      : (clamped ? 'clamp:safety-floor' : folded.verdictStatus),
     verdictSource: modelVerdict === null || clamped ? 'deterministic' : 'model',
     buckets: folded.buckets,
     batchId: built.batch.batchId,
     fallbackCode: clamped
-      ? 'truncated-findings'
+      ? 'safety-floor'
       : (modelVerdict === null
           ? (result?.fallbackCode ?? folded.status)
           : null),
@@ -450,7 +485,11 @@ function foldBatchResult(result, built, mode, stage) {
  */
 export async function runReviewVerdict({ findings, mode = 'solo', config,
   projectRoot, homeDir, env, transport } = {}) {
-  const built = buildReviewVerdictBatch({ findings, mode });
+  const capValue = config?.decisionPlane?.maxBatchQuestions;
+  const built = buildReviewVerdictBatch({
+    findings, mode,
+    maxQuestions: Number.isInteger(capValue) && capValue > 0 ? capValue : 8,
+  });
   const normalizedMode = mode === 'panel' ? 'panel' : 'solo';
   const stage = resolveReviewStage(config);