@ngockhoale/ukit 3.4.32 → 3.4.34

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

@@ -1791,6 +1791,28 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
   }
 
 
+// What exactly was ordered, so a receipt for a DIFFERENT verb/service/probe cannot discharge it.
+// Unnamed specifics stay empty (any proven receipt of the domain counts); named ones are required.
+const NOT_A_SERVICE = new Set(['it', 'this', 'that', 'them', 'the', 'all', 'everything', 'service', 'services', 'again', 'now', 'to', 'and', 'then']);
+function nativeOperationGoal(domain, actionable, text) {
+  const goal = { domain, target: null, desiredState: 'verified', completionSemantics: 'execute-and-verify', requiredTargets: [] };
+  const clauses = actionable.join(' . ');
+  if (domain === 'git-integrity') {
+    const verbs = [...clauses.matchAll(/\bgit\s+(push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)\b/g)].map((m) => m[1]);
+    if (/\bpush\s+(?:to\s+)?origin\b/.test(clauses)) verbs.push('push');
+    goal.requiredTargets = [...new Set(verbs)];
+    goal.check = /\bfsck\b/.test(text) ? 'fsck' : /\bdiff\s+--check\b/.test(text) ? 'diff-check' : null;
+    return goal;
+  }
+  const services = [...clauses.matchAll(/\b(?:restart|redeploy|deploy|khoi dong lai|trien khai)\s+(?:the\s+|lai\s+)?([a-z0-9][\w.-]*)/g)]
+    .map((m) => m[1]).filter((name) => !NOT_A_SERVICE.has(name));
+  goal.requiredTargets = [...new Set(services)];
+  const probePath = text.match(/(?:^|\s)(\/[a-z0-9_.-]+(?:\/[a-z0-9_.-]+)*)/)?.[1] || null;
+  const probeStatus = text.match(/\b(?:returns?|returning|responds?(?:\s+with)?|http|status(?:\s+code)?)\s+([1-5]\d\d)\b/)?.[1] || null;
+  if (probePath || probeStatus) goal.probe = { path: probePath, status: probeStatus };
+  return goal;
+}
+
 // 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();
@@ -1799,17 +1821,40 @@ 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 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 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 cronOperation = 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))
+    && (!codeChangeVerb || hasOperationId);
+  // Non-source operations (git history/push, service restart/deploy): ordered only by an
+  // actionable clause (negated/deferred/audit clauses are already filtered out). Git and
+  // 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)
+    && !/\.[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 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;
-  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+  // 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 || (nativeDomain !== 'scheduled-job' && codeChangeVerb) ? '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',
+  return { taskKind, ...(taskKind === 'READ_ONLY' && statusReport ? { statusReport: true } : {}), ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation && nativeDomain !== 'scheduled-job' ? { operationGoal: nativeOperationGoal(nativeDomain, actionable, text) } : {}),
+    ...(operation && nativeDomain === 'scheduled-job' ? { 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 +1865,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 };
 }
 
@@ -2242,6 +2288,15 @@ function applyTaskSemantics(contract, semantic) {
       // '…nhưng sửa phần này' order survives.
       .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
+      // 'đối chiếu' (cross-check) folds to 'doi chieu' and is not the verb 'đổi' (change).
+.replace(/\bdoi\s+chieu\b/g, ' ')
+// R2: a deferred/future clause ("chua sua", "how we would later implement", "R2 onward: ...",
+      // "fix strategy ...") describes work for a LATER round, not an order for this turn.
+      .replace(new RegExp(`\\bchua\\s+(?:sua|fix|implement|trien\\s+khai|viet|thay\\s+doi)\\b${WAIT_TAIL}`, 'g'), ' ')
+      .replace(/\bhow\s+(?:we|i|you|they)\s+(?:would|will|could|should|might)\b[^.,;\n?]*/g, ' ')
+      .replace(/\b(?:would|will|could|might)\s+later\b[^.,;\n?]*/g, ' ')
+      .replace(/\b(?:r\d+|round\s*\d+)\s+onward\b[^\n]*/g, ' ')
+      .replace(/\bfix\s+strategy\b[^\n]*/g, ' ')
       // C85-019b: a "khi <subject> <verb>" when-clause is temporal context —
       // "khi tôi cài hệ thống này" narrates WHEN something happens; the verb
       // inside it is never the order.
@@ -3625,6 +3680,15 @@ function applyTaskSemantics(contract, semantic) {
     if (continuingTask && previous.routingContext?.lastExplicitUserPromptText) {
       persisted.routingContext ||= {};
       persisted.routingContext.lastExplicitUserPromptText = previous.routingContext.lastExplicitUserPromptText;
+      // A tool event or a bare "continue" carries no order of its own: mutationOrder recomputed
+      // from a file path / the word "continue" says nothing about what the user ordered, so the
+      // original prompt's stamp stays authoritative.
+      if ((!extractPrompt(payload) || continuationPrompt) && typeof previous.routingContext.mutationOrder === 'boolean') {
+        persisted.routingContext.mutationOrder = previous.routingContext.mutationOrder;
+      }
+    }
+    if (continuingTask && !persisted.suspendedContract && previous.suspendedContract) {
+      persisted.suspendedContract = previous.suspendedContract;
     }
     const semantic = continuingTask && previous.routeSummary?.executionContract?.taskKind
       ? previous.routeSummary.executionContract
@@ -3632,11 +3696,39 @@ function applyTaskSemantics(contract, semantic) {
     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 +3739,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 +3766,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/post-edit-verify.mjs

@@ -276,6 +276,15 @@ if (process.argv[1] && path.basename(fileURLToPath(import.meta.url)) === path.ba
     process.stderr.write(`[ukit-safe-patch] post-edit ERROR: ${error?.message || error}\n`);
     // BUG-C23-01: stderr-only crash announces nothing to the user — §8 requires
     // the paired stdout systemMessage before the non-zero exit.
+    // A containment refusal is the guard working, not a crash: the target is outside the
+    // project (and any listed linked worktree), so it is still refused and never read.
+    if (/^Path escapes project root:/.test(String(error?.message || ''))) {
+      emitSystemMessage(
+        `UKit Safe Patch refused an out-of-project edit target (${error.message}); `
+        + 'post-edit verification was NOT run for it. This is a scope refusal, not a hook crash.',
+      );
+      process.exit(1);
+    }
     emitSystemMessage(
       `UKit post-edit-verify crashed before it could verify the edit (${error?.message || error}); `
       + 'the Safe Patch check was skipped this pass. Run `ukit doctor` if this repeats.',

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

@@ -1063,6 +1063,28 @@ export function deriveRouteFields({
   };
 }
 
+// What exactly was ordered, so a receipt for a DIFFERENT verb/service/probe cannot discharge it.
+// Unnamed specifics stay empty (any proven receipt of the domain counts); named ones are required.
+const NOT_A_SERVICE = new Set(['it', 'this', 'that', 'them', 'the', 'all', 'everything', 'service', 'services', 'again', 'now', 'to', 'and', 'then']);
+function nativeOperationGoal(domain, actionable, text) {
+  const goal = { domain, target: null, desiredState: 'verified', completionSemantics: 'execute-and-verify', requiredTargets: [] };
+  const clauses = actionable.join(' . ');
+  if (domain === 'git-integrity') {
+    const verbs = [...clauses.matchAll(/\bgit\s+(push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)\b/g)].map((m) => m[1]);
+    if (/\bpush\s+(?:to\s+)?origin\b/.test(clauses)) verbs.push('push');
+    goal.requiredTargets = [...new Set(verbs)];
+    goal.check = /\bfsck\b/.test(text) ? 'fsck' : /\bdiff\s+--check\b/.test(text) ? 'diff-check' : null;
+    return goal;
+  }
+  const services = [...clauses.matchAll(/\b(?:restart|redeploy|deploy|khoi dong lai|trien khai)\s+(?:the\s+|lai\s+)?([a-z0-9][\w.-]*)/g)]
+    .map((m) => m[1]).filter((name) => !NOT_A_SERVICE.has(name));
+  goal.requiredTargets = [...new Set(services)];
+  const probePath = text.match(/(?:^|\s)(\/[a-z0-9_.-]+(?:\/[a-z0-9_.-]+)*)/)?.[1] || null;
+  const probeStatus = text.match(/\b(?:returns?|returning|responds?(?:\s+with)?|http|status(?:\s+code)?)\s+([1-5]\d\d)\b/)?.[1] || null;
+  if (probePath || probeStatus) goal.probe = { path: probePath, status: probeStatus };
+  return goal;
+}
+
 // 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();
@@ -1071,17 +1093,40 @@ 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 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 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 cronOperation = 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))
+    && (!codeChangeVerb || hasOperationId);
+  // Non-source operations (git history/push, service restart/deploy): ordered only by an
+  // actionable clause (negated/deferred/audit clauses are already filtered out). Git and
+  // 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)
+    && !/\.[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 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;
-  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+  // 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 || (nativeDomain !== 'scheduled-job' && codeChangeVerb) ? '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',
+  return { taskKind, ...(taskKind === 'READ_ONLY' && statusReport ? { statusReport: true } : {}), ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation && nativeDomain !== 'scheduled-job' ? { operationGoal: nativeOperationGoal(nativeDomain, actionable, text) } : {}),
+    ...(operation && nativeDomain === 'scheduled-job' ? { 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 +1137,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,
@@ -2116,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
@@ -2162,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 ?? [],
@@ -2186,6 +2203,7 @@ export async function emitResumableRun({
   projectVerification = null,
   signal = null,
   deadlineMs = null,
+  decomposition = null,
 } = {}) {
   const stage = resolveResumableRunStage(config);
   if (stage === 'off') return null;
@@ -2212,6 +2230,7 @@ export async function emitResumableRun({
       routeSummary,
       previousRecord,
       sourceSnapshot,
+      decomposition,
     });
     const write = await writeResumableRun(rootDir, record, {
       signal,
@@ -2251,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',
@@ -2275,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 ?? [];
@@ -2537,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,
@@ -2593,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}`);
   }
@@ -4470,6 +4566,15 @@ function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
     // '…nhưng sửa phần này' order survives.
     .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
     .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
+    // 'đối chiếu' (cross-check) folds to 'doi chieu' and is not the verb 'đổi' (change).
+.replace(/\bdoi\s+chieu\b/g, ' ')
+// R2: a deferred/future clause ("chua sua", "how we would later implement", "R2 onward: ...",
+    // "fix strategy ...") describes work for a LATER round, not an order for this turn.
+    .replace(new RegExp(`\\bchua\\s+(?:sua|fix|implement|trien\\s+khai|viet|thay\\s+doi)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(/\bhow\s+(?:we|i|you|they)\s+(?:would|will|could|should|might)\b[^.,;\n?]*/g, ' ')
+    .replace(/\b(?:would|will|could|might)\s+later\b[^.,;\n?]*/g, ' ')
+    .replace(/\b(?:r\d+|round\s*\d+)\s+onward\b[^\n]*/g, ' ')
+    .replace(/\bfix\s+strategy\b[^\n]*/g, ' ')
     // C85-019b: a "khi <subject> <verb>" when-clause is temporal context —
     // "khi tôi cài hệ thống này" narrates WHEN something happens; the verb
     // inside it is never the order.