@ngockhoale/ukit 3.4.31 → 3.4.33

package/template_project/.claude/hooks/handoff-model-guard.sh

@@ -135,6 +135,12 @@ if printf '%s' "$INPUT" | grep -qE '"tool_name"[[:space:]]*:[[:space:]]*"(Agent|
   && printf '%s' "$INPUT" | grep -qE 'TASK-([Cc][0-9]+-)?[0-9]+'; then
   TASK_CLAIM_RUN=1
 fi
+# Adaptive task-graph pre-filter: a delegation tagged [ukit-subtask <id>] needs the dependency gate.
+SUBTASK_RUN=0
+if printf '%s' "$INPUT" | grep -qE '"tool_name"[[:space:]]*:[[:space:]]*"(Agent|Task)"' \
+  && printf '%s' "$INPUT" | grep -qF '[ukit-subtask '; then
+  SUBTASK_RUN=1
+fi
 # Main-agent ownership pre-filter: a source Edit/Write only needs the node gate while a
 # handoff-fullstack run sits in an implement phase (cheap RUN.md grep, no node spawn otherwise).
 MAIN_OWNER_RUN=0
@@ -142,11 +148,11 @@ if printf '%s' "$INPUT" | grep -qE '"tool_name"[[:space:]]*:[[:space:]]*"(Edit|W
   && grep -qE '^Phase:[[:space:]]*I[1-4]\b' "$PROJECT_ROOT/docs/AI_HANDOFF/RUN.md" 2>/dev/null; then
   MAIN_OWNER_RUN=1
 fi
-if [ "$CREATE_SCOPE_RUN" != 1 ] && [ "$TASK_CLAIM_RUN" != 1 ] && [ "$MAIN_OWNER_RUN" != 1 ] && ! printf '%s' "$INPUT" | grep -qE 'AI_HANDOFF|git[[:space:]]+push'; then
+if [ "$CREATE_SCOPE_RUN" != 1 ] && [ "$TASK_CLAIM_RUN" != 1 ] && [ "$SUBTASK_RUN" != 1 ] && [ "$MAIN_OWNER_RUN" != 1 ] && ! printf '%s' "$INPUT" | grep -qE 'AI_HANDOFF|git[[:space:]]+push'; then
   exit 0
 fi
 
-INPUT_FILE="$UKIT_INPUT_FILE" PROJECT_ROOT="$PROJECT_ROOT" CREATE_SCOPE_RUN="$CREATE_SCOPE_RUN" TASK_CLAIM_RUN="$TASK_CLAIM_RUN" HOOK_DIR="$SCRIPT_DIR" node <<'NODE'
+INPUT_FILE="$UKIT_INPUT_FILE" PROJECT_ROOT="$PROJECT_ROOT" CREATE_SCOPE_RUN="$CREATE_SCOPE_RUN" TASK_CLAIM_RUN="$TASK_CLAIM_RUN" SUBTASK_RUN="$SUBTASK_RUN" HOOK_DIR="$SCRIPT_DIR" node <<'NODE'
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10) || 3000;
 // SPEC §8: a timed-out gate silently passes work it never evaluated — announce the
 // degrade (fail-open posture kept: still exit 0).
@@ -793,6 +799,35 @@ async function taskClaimGate() {
 }
 await taskClaimGate();
 
+// Adaptive-decomposition task graph: a delegation tagged `[ukit-subtask <id>]` is dispatched only
+// when its dependencies are done and it is neither running nor already done (resume never
+// re-dispatches finished work). Untagged delegations and IO trouble pass through untouched.
+async function subtaskGate() {
+  if (process.env.SUBTASK_RUN !== '1' || toolName !== 'Agent' && toolName !== 'Task') return;
+  try {
+    const dispatch = await import(require('url').pathToFileURL(path.resolve(process.env.HOOK_DIR || '.', '../ukit/runtime/plan-dispatch.mjs')).href);
+    const subtaskId = dispatch.subtaskIdFromInput(input);
+    if (!subtaskId) return;
+    const verdict = await dispatch.dispatchSubtask(projectRoot, subtaskId, input);
+    if (verdict.ok) {
+      const b = verdict.budget;
+      if (b && (b.status === 'over-soft-budget' || b.status === 'over-cost-boundary')) {
+        process.on('exit', (code) => {
+          if (code !== 0) return;
+          try { fs.writeSync(1, `${JSON.stringify({ systemMessage: `UKit: subtask ${subtaskId} scoped context (over the ${b.role} soft budget of ${b.softBudget} tokens) — consider splitting it further. Advisory only; dispatch proceeds.` })}\n`); } catch {}
+        });
+      }
+      return;
+    }
+    const why = verdict.reason === 'deps-pending' ? `dependencies not done yet: ${(verdict.missing || []).join(', ')}`
+      : verdict.reason === 'already-done' ? 'it is already done (resume never re-dispatches completed subtasks)'
+        : verdict.reason === 'already-running' ? 'it is already running'
+          : verdict.reason;
+    block(`Subtask ${subtaskId} not dispatched: ${why}. Dispatch the ready subtasks first (see the route "plan:" lines); integrate last.`);
+  } catch { /* fail-open on IO trouble */ }
+}
+await subtaskGate();
+
 // Main-agent task ownership. handoff-fullstack contracts implementation to claim-bearing
 // executor subagents ("Do NOT implement the tasks yourself in the current session"). The
 // delegation path is claim-gated above; this closes the direct path: while a run is in an

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

@@ -53,6 +53,15 @@ async function releaseDelegatedClaims(payload, projectRoot) {
       await mod.renewSessionClaims(projectRoot, String(payload.session_id));
     }
     if (payload.tool_name !== 'Agent' && payload.tool_name !== 'Task') return;
+    try {
+      const dispatch = await import(pathToFileURL(path.join(MODULE_DIR, '..', 'ukit', 'runtime', 'plan-dispatch.mjs')).href);
+      const subtaskId = dispatch.subtaskIdFromInput(payload.tool_input);
+      if (subtaskId) {
+        const r = payload.tool_response ?? payload.tool_output ?? payload.tool_result ?? {};
+        const failed = [payload.is_error, r?.is_error, r?.isError, payload.tool_response?.isError].some((v) => v === true);
+        await dispatch.completeSubtask(projectRoot, subtaskId, { success: !failed });
+      }
+    } catch { /* advisory */ }
     const owner = mod.delegatedClaimOwner(payload);
     if (!owner) return;
     for (const { taskId } of mod.delegatedClaimTargets(payload.tool_input)) {

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

@@ -1799,16 +1799,27 @@ function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
     && !/^\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 codeChangeVerb = actionable.some((clause) => /\b(?:implement|fix|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
+  const hasOperationId = /\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/.test(text);
+  // A cron/job MENTION is not an operation: with a code-change verb in the request, an
+  // operation needs a concrete target id; otherwise it is a coding task about scheduling.
   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));
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause))
+    && (!codeChangeVerb || hasOperationId);
+  const config = !sourceOrder && actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause)
+    && /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi|bat|tat|chinh)\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;
+  // A status/result lookup ("check the suite output and report") orders no change: it needs a
+  // lookup verb AND no mutation vocabulary anywhere in the request (fail-closed otherwise).
+  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)\b/.test(text);
+  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text) || statusReport)
+    && !sourceOrder && !codeChangeVerb && !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' } : {}),
+  return { taskKind, ...(taskKind === 'READ_ONLY' && statusReport ? { statusReport: true } : {}), ...(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' } } : {}) };
 }
@@ -1820,6 +1831,7 @@ function applyTaskSemantics(contract, semantic) {
   return { ...(contract || {}), ...semantic,
     completionEvidence: 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 };
 }
 
@@ -3626,17 +3638,48 @@ function applyTaskSemantics(contract, semantic) {
       persisted.routingContext ||= {};
       persisted.routingContext.lastExplicitUserPromptText = previous.routingContext.lastExplicitUserPromptText;
     }
+    if (continuingTask && !persisted.suspendedContract && previous.suspendedContract) {
+      persisted.suspendedContract = previous.suspendedContract;
+    }
     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) {
+      // An answer-only turn must not enforce carried write debt, but it must not ERASE the
+      // contract either: park it (session- and task-bound) so a continuation or the next
+      // tool event of the same session restores it instead of finding "no contract routed".
+      const parked = previous.routeSummary?.executionContract?.completionEvidence?.length
+        ? { sessionId, taskInstanceId: previous.taskInstanceId, requestKey: previous.requestKey,
+            routeSummary: previous.routeSummary, routingContext: previous.routingContext, ts: Date.now() }
+        : previous.suspendedContract;
+      if (parked) persisted.suspendedContract = parked;
       delete persisted.routeSummary;
       delete persisted.requestKey;
-    } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary) {
+    } else if (semantic.statusReport && !continuingTask) {
+      // A status/result lookup is a read-only turn with its own task id: it carries no write
+      // debt, but it must not erase a running implementation's contract — park it for `continue`.
+      const prior = previous.routeSummary?.executionContract;
+      const parked = prior && !prior.statusReport && prior.completionEvidence?.length
+        ? { sessionId, taskInstanceId: previous.taskInstanceId, requestKey: previous.requestKey,
+            routeSummary: previous.routeSummary, routingContext: previous.routingContext, ts: Date.now() }
+        : previous.suspendedContract;
+      if (parked) persisted.suspendedContract = parked;
       persisted.routeSummary ||= { executionMode: 'local-build' };
       persisted.routeSummary.executionContract = applyTaskSemantics(
+        persisted.routeSummary.executionContract || buildExecutionContract('local-build'), semantic);
+      delete persisted.routeSummary.completionState;
+      delete persisted.routeSummary.continuationState;
+    } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary) {
+      persisted.routeSummary ||= { executionMode: 'local-build' };
+      // A carried status-report contract must not leak its empty evidence / flag onto a
+      // turn that is not itself a status lookup: rebuild the base contract instead.
+      const carriedStatus = persisted.routeSummary.executionContract?.statusReport === true && !semantic.statusReport;
+      if (carriedStatus && persisted.routingContext?.mutationOrder === true) {
+        delete persisted.routeSummary.executionContract;
+      }
+      if (!carriedStatus || persisted.routingContext?.mutationOrder === true) 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')) {
@@ -3647,6 +3690,12 @@ function applyTaskSemantics(contract, semantic) {
         persisted.routeSummary.continuationState = buildContinuationState({ completionState: persisted.routeSummary.completionState });
       }
     }
+    // Keep a parked implementation contract alive across further answer/status turns of the
+    // same session (previous is already session-scoped); a fresh implementation route drops it.
+    if (!persisted.suspendedContract && previous.suspendedContract
+      && (!persisted.routeSummary || persisted.routeSummary.executionContract?.statusReport)) {
+      persisted.suspendedContract = previous.suspendedContract;
+    }
     text = JSON.stringify(persisted);
     await writeJsonFileAtomic(statePath, text);
     if (!sessionId) return;
@@ -3668,11 +3717,22 @@ function applyTaskSemantics(contract, semantic) {
   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
+  let previous = sessionId
     ? [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());
+  // Restore a contract parked by an informational turn: only for the SAME session, and only
+  // on an explicit continuation or a mutating tool event (never a fresh prompt, which routes on its own,
+  // and never a read during an answer/status turn: that must not resurrect write debt).
+  const parkedContract = previous.suspendedContract;
+  if ((!previous.routeSummary || previous.routeSummary?.executionContract?.statusReport) && parkedContract?.routeSummary && parkedContract.taskInstanceId
+    && sessionId && parkedContract.sessionId === sessionId
+    && (continuationPrompt || /^(?:Edit|Write|MultiEdit|NotebookEdit)$/.test(String(payload.tool_name || '')))) {
+    previous = { ...previous, taskInstanceId: parkedContract.taskInstanceId, routeSummary: parkedContract.routeSummary,
+      requestKey: parkedContract.requestKey, routingContext: parkedContract.routingContext || previous.routingContext };
+    delete previous.suspendedContract;
+  }
   const continuingTask = Boolean(previous.taskInstanceId && (payload.tool_name || continuationPrompt));
   const taskInstanceId = continuingTask
     ? previous.taskInstanceId

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 } : {}),
   };
 }
 
@@ -413,11 +428,19 @@ function foldBatchResult(result, built, mode, stage) {
       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
@@ -433,8 +456,10 @@ function foldBatchResult(result, built, mode, stage) {
   // 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,
@@ -460,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);
 

package/template_project/.claude/ukit/index/route-resolver.mjs

@@ -1071,16 +1071,29 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
     && !/^\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 codeChangeVerb = actionable.some((clause) => /\b(?:implement|fix|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
+  const hasOperationId = /\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/.test(text);
+  // A cron/job MENTION is not an operation: with a code-change verb in the request, an
+  // operation needs a concrete target id; otherwise it is a coding task about scheduling.
   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));
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause))
+    && (!codeChangeVerb || hasOperationId);
+  // 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)
+    && /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi|bat|tat|chinh)\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;
+  // A status/result lookup ("check the suite output and report") orders no change: it needs a
+  // lookup verb AND no mutation vocabulary anywhere in the request (fail-closed otherwise).
+  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)\b/.test(text);
+  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text) || statusReport)
+    && !sourceOrder && !codeChangeVerb && !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' } : {}),
+  return { taskKind, ...(taskKind === 'READ_ONLY' && statusReport ? { statusReport: true } : {}), ...(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' } } : {}) };
 }
@@ -1092,5 +1105,6 @@ export function applyTaskSemantics(contract, semantic) {
   return { ...(contract || {}), ...semantic,
     completionEvidence: 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 };
 }

package/template_project/.claude/ukit/index/route-task.mjs

@@ -73,6 +73,7 @@ import {
 import { applyMeasuredTier, loadTierMap } from './tier-selection.mjs';
 import { resolvePlaybookRoute, loadRegistry, deriveRouteOrchestrationSignals } from './playbook-registry.mjs';
 import { extractHistorySignalsAsync } from './session-history-extractor.mjs';
+import { carryProgress, buildDecompositionPlan, estimateContextWindow, MIN_AUTO_SPLIT_CONFIDENCE } from '../runtime/context-budget-policy.mjs';
 import {
   applyFixLoopEscalation,
   isFixLoopEscalationDue,
@@ -1060,6 +1061,7 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
     preparedRoute,
     projectVerification,
     cachedContextResult: helperCacheSnapshot.contextResult,
+    transcriptPath: normalizedInput.transcriptPath ?? process.env.UKIT_TRANSCRIPT_PATH ?? null,
     cachedVerificationPlan: helperCacheSnapshot.verificationPlan,
     useIndexedContext,
     previousContextSnapshot,
@@ -1390,6 +1392,7 @@ async function main() {
     commandNamespace,
     preparedRoute,
     projectVerification,
+    transcriptPath,
     cachedContextResult: helperCacheSnapshot.contextResult,
     cachedVerificationPlan: helperCacheSnapshot.verificationPlan,
     useIndexedContext,
@@ -1663,6 +1666,11 @@ function probabilityBand(value) {
 // executionMode. The review/cross-check/verification-depth baselines are
 // produced by later wave modules; until then their baseline stays null and
 // receipts record bands + agreement 'unknown' — real data, not fabricated.
+// Route-shadow questions that add no observation: asked authoritatively by the
+// fix-loop escalation batch (verification.depth.v1) and without a route-level
+// baseline to compare against here.
+const SHADOW_REDUNDANT_KEYS = new Set(['verification.depth.v1']);
+
 function shadowBaselineFor(decisionKey, routeSummary) {
   if (decisionKey === 'route.intent-kind.v1') return routeSummary?.intent?.kind ?? null;
   if (decisionKey === 'route.rigor.v1') return routeSummary?.execution?.rigor ?? null;
@@ -1819,7 +1827,42 @@ export async function runRouteDecisionShadow({
   // Greeting fast-path: a social turn carries nothing the decision plane could
   // answer — never spawn the adapter shadow for one.
   if (routingContext?.greetingFastPath) return null;
-  const questions = buildShadowDecisionQuestions(config);
+  // Observation-only batch: honour the adapter request caps without a second
+  // call. Selection is semantic, not positional: (1) enums over maxEnumLabels
+  // are never truncated, they are skipped (`enum-cap`); (2) questions the route
+  // cannot compare to a deterministic baseline AND that another stage already
+  // asks authoritatively are redundant here; (3) the remainder is ranked
+  // baseline-comparable first, table order within a rank, and cut at
+  // maxBatchQuestions (`batch-cap`). Every skip is reported with its reason.
+  const shadowCaps = {
+    batch: Number.isInteger(config?.decisionPlane?.maxBatchQuestions) && config.decisionPlane.maxBatchQuestions > 0
+      ? config.decisionPlane.maxBatchQuestions : 8,
+    labels: Number.isInteger(config?.decisionPlane?.maxEnumLabels) && config.decisionPlane.maxEnumLabels > 0
+      ? config.decisionPlane.maxEnumLabels : 11,
+  };
+  const wanted = buildShadowDecisionQuestions(config);
+  const skippedDecisions = [];
+  const candidatesForBatch = [];
+  for (const q of wanted) {
+    if ((q.candidates?.length ?? 0) > shadowCaps.labels) {
+      skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'enum-cap' });
+    } else if (SHADOW_REDUNDANT_KEYS.has(q.decisionKey)) {
+      skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'redundant' });
+    } else {
+      candidatesForBatch.push(q);
+    }
+  }
+  const hasBaseline = (q) => shadowBaselineFor(q.decisionKey, routeSummary) != null;
+  const ranked = [
+    ...candidatesForBatch.filter(hasBaseline),
+    ...candidatesForBatch.filter((q) => !hasBaseline(q)),
+  ];
+  const picked = new Set(ranked.slice(0, shadowCaps.batch));
+  for (const q of candidatesForBatch) {
+    if (!picked.has(q)) skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'batch-cap' });
+  }
+  const questions = candidatesForBatch.filter((q) => picked.has(q));
+  const skippedDecisionKeys = skippedDecisions.map((d) => d.decisionKey);
   if (questions.length === 0) {
     return { stage, outcomeClass: 'skipped', decisionKeys: [], probabilityBands: {},
       checkpoint: null, latencyClass: 'unknown', fallbackCode: 'no-enabled-families',
@@ -1904,6 +1947,10 @@ export async function runRouteDecisionShadow({
     };
   }
 
+  // Partial coverage is never reported as full success.
+  if (skippedDecisions.length > 0 && result.status === 'accepted') {
+    result = { ...result, status: 'partial' };
+  }
   const receipt = buildDecisionShadowReceipt({
     stage,
     result,
@@ -1960,7 +2007,14 @@ export async function runRouteDecisionShadow({
       // Receipt loss is advisory — never fail the route over telemetry.
     }
   }
-  return receipt;
+  return skippedDecisions.length > 0
+    ? {
+        ...receipt,
+        skippedDecisionKeys,
+        skippedDecisions,
+        coverage: { asked: questions.length, total: wanted.length, complete: false },
+      }
+    : receipt;
 }
 
 // BL-018 (SPEC FR-006): the bounded-question `ask` seam — one batch through
@@ -2065,12 +2119,26 @@ function resumableTaskId({ sessionId = null, taskBoundary }) {
 // (hypotheses/decisions/failures) and completed receipts carry forward; a new
 // boundary starts a fresh record. The phase that just completed is appended to
 // completedBlocks when it changes.
+// The adaptive-decomposition plan rides the record as ONE `decisions` entry
+// (type 'decomposition'), replaced in place so replans never accumulate. Loop
+// state (depth/attempts/seenFingerprints) lives in it, so a re-route of the same
+// task reads it back and shouldDecompose refuses an unchanged split.
+export function findDecompositionDecision(decisions) {
+  return (Array.isArray(decisions) ? decisions : []).find((d) => d && typeof d === 'object' && d.type === 'decomposition') ?? null;
+}
+function mergeDecompositionDecision(decisions, decomposition) {
+  if (!decomposition?.decompose) return decisions;
+  const rest = decisions.filter((d) => !(d && typeof d === 'object' && d.type === 'decomposition'));
+  return [...rest, { type: 'decomposition', ...decomposition }].slice(-12);
+}
+
 function buildResumableRunRecord({
   taskId,
   taskBoundary,
   routeSummary,
   previousRecord = null,
   sourceSnapshot,
+  decomposition = null,
 }) {
   const previous = previousRecord && previousRecord.taskBoundary === taskBoundary
     ? previousRecord
@@ -2111,7 +2179,7 @@ function buildResumableRunRecord({
     },
     invariants: previous?.invariants ?? [],
     hypotheses: previous?.hypotheses ?? [],
-    decisions: previous?.decisions ?? [],
+    decisions: mergeDecompositionDecision(previous?.decisions ?? [], decomposition),
     evidenceRefs: previous?.evidenceRefs ?? [],
     escalationHistory: previous?.escalationHistory ?? [],
     unresolvedFailures: previous?.unresolvedFailures ?? [],
@@ -2135,6 +2203,7 @@ export async function emitResumableRun({
   projectVerification = null,
   signal = null,
   deadlineMs = null,
+  decomposition = null,
 } = {}) {
   const stage = resolveResumableRunStage(config);
   if (stage === 'off') return null;
@@ -2161,6 +2230,7 @@ export async function emitResumableRun({
       routeSummary,
       previousRecord,
       sourceSnapshot,
+      decomposition,
     });
     const write = await writeResumableRun(rootDir, record, {
       signal,
@@ -2200,6 +2270,63 @@ export async function emitResumableRun({
   }
 }
 
+// Runtime caller of the decomposition policy. Context size = newest provider usage in the
+// transcript tail (high confidence); bytes/4 is only a LOW-confidence fallback that never
+// auto-splits (no LLM, no tokenizer). Runs only when the stage is on and a transcript
+// pointer exists; returns null otherwise. Pricing metadata comes from
+// config.contextBudget.pricing when present — without it the 100K boundary is still
+// used as the planning threshold (shouldDecompose default) but nothing is claimed
+// about billing. Never throws.
+export async function planAdaptiveDecomposition({ rootDir, config, routeSummary, routingContext, contextRecommendation, transcriptPath, sessionId }) {
+  try {
+    if (resolveResumableRunStage(config) === 'off' || routingContext?.greetingFastPath || !transcriptPath) return null;
+    const st = await fs.stat(transcriptPath).catch(() => null);
+    if (!st?.isFile()) return null;
+    const preview = contextRecommendation?.preview ?? contextRecommendation ?? {};
+    const primaryTargets = (preview.primaryTargets ?? []).filter((f) => typeof f === 'string').slice(0, 24);
+    const relatedTests = (preview.relatedTests ?? []).filter((f) => typeof f === 'string').slice(0, 24);
+    const fileTokens = {};
+    for (const f of [...primaryTargets, ...relatedTests]) {
+      const fst = await fs.stat(path.resolve(rootDir, f)).catch(() => null);
+      if (fst?.isFile()) fileTokens[f] = Math.ceil(fst.size / 4);
+    }
+    let tailLines = [];
+    try {
+      const fh = await fs.open(transcriptPath, 'r');
+      try {
+        const len = Math.min(st.size, 512 * 1024);
+        const buf = Buffer.alloc(len);
+        await fh.read(buf, 0, len, st.size - len);
+        tailLines = buf.toString('utf8').split('\n').filter(Boolean).slice(-200);
+      } finally { await fh.close(); }
+    } catch { /* fall back to the byte estimate */ }
+    const estimate = estimateContextWindow({ tailLines, transcriptBytes: st.size });
+    const taskBoundary = resumableTaskBoundary(routingContext);
+    const taskId = resumableTaskId({ sessionId, taskBoundary });
+    const resumed = await readResumableRun(rootDir, { taskId, taskBoundary });
+    const previous = findDecompositionDecision(resumed.record?.decisions);
+    const sharedFiles = new Set(primaryTargets).size < primaryTargets.length;
+    const plan = buildDecompositionPlan({
+      parentId: taskId,
+      goal: String(routingContext?.lastExplicitUserPromptText ?? routingContext?.promptText ?? '').slice(0, 200),
+      contextTokens: MIN_AUTO_SPLIT_CONFIDENCE.has(estimate.confidence) ? estimate.tokens : null,
+      primaryTargets,
+      relatedTests,
+      fileTokens,
+      acceptance: routeSummary?.executionContract?.completionEvidence ?? [],
+      coupled: sharedFiles || primaryTargets.length < 2,
+      pricing: config?.contextBudget?.pricing ?? null,
+      previous,
+    });
+    if (!plan.decompose && plan.reason === 'unknown-size') {
+      return { ...plan, reason: `low-confidence-estimate:${estimate.source}`, estimatedTokens: estimate.tokens };
+    }
+    return carryProgress(previous, { ...plan, estimateSource: estimate.source, estimateConfidence: estimate.confidence });
+  } catch {
+    return null;
+  }
+}
+
 async function finalizeTaskRoute({
   rootDir = process.cwd(),
   commandNamespace = '.claude',
@@ -2224,6 +2351,7 @@ async function finalizeTaskRoute({
   // BL-013: precomputed bounded history struct from the caller's transcript
   // extraction — merged into the route record additively + decisions.tsv.
   historySignals = null,
+  transcriptPath = null,
 } = {}) {
   const absoluteRoot = path.resolve(rootDir);
   const activeSkills = preparedRoute?.activeSkills ?? [];
@@ -2486,7 +2614,20 @@ async function finalizeTaskRoute({
   // persisted/updated under .ukit/storage/runs/ and a bounded pointer lands on
   // the execution ledger. The pointer rides routeSummary.resumableRun so the
   // shared route state carries the taskId reinject-context resumes from.
+  const decomposition = await planAdaptiveDecomposition({
+    rootDir: absoluteRoot,
+    config: escalationConfig,
+    routeSummary,
+    routingContext,
+    contextRecommendation,
+    transcriptPath,
+    sessionId,
+  });
+  if (decomposition?.decompose) {
+    routeSummary.decompositionPlan = decomposition;
+  }
   const resumableRun = await emitResumableRun({
+    decomposition,
     rootDir: absoluteRoot,
     config: escalationConfig,
     routeSummary,
@@ -2542,6 +2683,12 @@ function printRouteState(state) {
     );
   }
   console.log(`summary: ${compactSummary}`);
+  const plan = state.routeSummary?.decompositionPlan;
+  if (plan?.decompose) {
+    console.log(`plan: decomposed into ${plan.tasks.length} steps (est ${plan.estimatedTokens} tok, savings ${plan.costs?.savingsRatio}) — dispatch each scoped subtask to a subagent with only its files + handoff, then integrate`);
+    const doneIds = new Set(plan.done ?? []);
+    for (const t of plan.tasks) console.log(`  - ${t.id}: ${t.files.join(', ') || 'integration'} deps=[${t.deps.join(',')}]${doneIds.has(t.id) ? ' DONE' : ''} — start the Agent prompt with "[ukit-subtask ${t.id}]"`);
+  }
   if (state.routeSummary?.executionContract?.modelTier) {
     console.log(`modelTier: ${state.routeSummary.executionContract.modelTier}`);
   }