@ngockhoale/ukit 3.4.69 → 3.4.70

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

@@ -197,27 +197,545 @@ const os = require('os');
 const { pathToFileURL } = require('url');
 const { spawn } = require('child_process');
 
-// Wall-clock watchdog. This hook runs on the UserPromptSubmit/PreToolUse hot path but has
-// no host-side process-group kill: when indexed-context resolution hangs (a wedged import,
-// a stalled mount), the host kills only THIS bash wrapper, the node grandchild below is
-// reparented to launchd, and it spins forever. Verified: exactly one orphan leaked per run
-// of the router timeout test, 200+ accumulated over days. Self-exit at the deadline so a
-// hang can never outlive the hook. Advisory only — an early exit just drops the routing
-// hint, the same posture as a cache miss. Same watchdog task-watchdog.sh/handoff-resume.sh
-// already carry; keep this one aligned with them.
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || '', 10) || 3000;
 setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
 
 (async () => {
+// BEGIN GENERATED SEMANTIC ENGINE sha256=4a3ee8d8789589bab57ab21ad404a2a09a1ff45b31e5d5204c87a2604e305fd2
+// Canonical task semantics; intent never grants authorization or proves completion.
+const SEMANTIC_ENGINE_VERSION = 'round4-semantic-1:1dcaa0253e7bc7f4356b02fe5de33b1edda6f0e00d9f2022d9c8cdbe907003a2';
+
+function semanticContractIdentity({ promptText = '', targetFile = '', taskInstanceId = null } = {}) {
+  return { taskInstanceId, targetFile, engineVersion: SEMANTIC_ENGINE_VERSION,
+    promptFingerprint: crypto.createHash('sha256').update(String(promptText)).digest('hex') };
+}
+
+const semanticContractShape = (contract) => JSON.stringify([
+  contract?.taskKind, contract?.publication === true, contract?.operationGoal ?? null,
+  contract?.configurationScope ?? null, contract?.releasePolicy ?? null, contract?.conditionalObligations ?? null,
+  contract?.reportArtifact ?? null, contract?.verificationOnly === true, contract?.statusReport === true,
+  [...(contract?.completionEvidence || [])].sort(),
+]);
+function compareSemanticContracts({ stored, fresh, previousIdentity, identity }) {
+  if (semanticContractShape(stored) === semanticContractShape(fresh)) return { status: 'equal', identity };
+  const sameInput = previousIdentity && previousIdentity.taskInstanceId === identity.taskInstanceId
+    && previousIdentity.promptFingerprint === identity.promptFingerprint && previousIdentity.targetFile === identity.targetFile;
+  const status = sameInput && previousIdentity.engineVersion === identity.engineVersion ? 'invariant-violation'
+    : sameInput ? 'engine-migration' : previousIdentity ? 'input-change' : 'legacy-migration';
+  return { status, identity, previousIdentity, stored, rederived: fresh };
+}
+const foldIntent = (text) => String(text).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
+
+function analyzeTaskIntent({ promptText = '', targetFile = '', taskInstanceId = null, sessionId = null } = {}) {
+  const original = String(promptText);
+  const spans = [];
+  let fence = null;
+  let description = false;
+  let offset = 0;
+  for (const rawLine of original.split(/(?<=\n)/)) {
+    const label = foldIntent(rawLine).replace(/^[\s#*\d.)-]+/, '').trim();
+    const bullet = /^\s*(?:[-*+•]|\d+[.)])\s+/.test(rawLine);
+    const marker = rawLine.match(/^\s*(`{3,}|~{3,})/);
+    if (marker) fence = fence ? null : marker[1][0];
+    const execution = /^(?:now |then |please )*(?:execute|perform|follow|run)\b.*\b(?:steps?|workflow|instructions)\b|^(?:instructions|commands|yeu cau)\s*:/.test(label);
+    if (execution) description = false;
+    else if (/\b(?:examples?|cases|inputs?|reproductions?|history|historical|observed|expected|distinguish|compare|checklist|findings)\b[^\n]*:\s*$/.test(label)) description = true;
+    else if (!bullet && label && !/:\s*$/.test(label)) description = false;
+    const parts = [...rawLine.replace(/\r/g, ' ').matchAll(/.+?(?:[;\n]|\.(?=\s|$)|(?=\s*(?:,\s*)?(?:but|then|however|nhưng|sau đó)\s+(?:(?:now|please|run)\s+)*(?:implement|fix|modify|edit|apply|restart|deploy|publish|git|sửa)\b)|$)/gi)];
+    for (const part of parts) {
+      const raw = rawLine.slice(part.index, part.index + part[0].length);
+      const text = foldIntent(raw);
+      const quoted = Boolean(marker || fence || /^\s*>/.test(raw));
+      const context = quoted ? 'quotation' : description && bullet ? 'description' : 'instruction';
+      const polarity = /\b(?:do not|don't|never|must not|no|khong|chua)\b|đừng/i.test(raw) || /\b(?:prohibited|forbidden|banned)\b/.test(text) ? 'prohibited' : 'affirmative';
+      const condition = text.match(/\b(?:if|neu|only if|only when)\b[^,;.\n]*/)?.[0] || null;
+      spans.push({ start: offset + part.index, end: offset + part.index + raw.length, raw,
+        context, polarity, condition, activation: condition ? 'pending' : context !== 'instruction' || polarity === 'prohibited' ? 'inactive' : 'eligible' });
+    }
+    offset += rawLine.length;
+  }
+  for (let index = 1; index < spans.length; index += 1) {
+    const span = spans[index];
+    if (!span.condition && /^\s*otherwise\b/.test(foldIntent(span.raw)) && spans[index - 1].condition) {
+      span.condition = `otherwise:${spans[index - 1].condition}`;
+      span.activation = 'pending';
+    }
+  }
+  let semanticInput = original;
+  // Preserve the existing native preflight and defect-repair lifecycles. Other
+  // leading predicates have no receipt resolver yet: retain them as pending
+  // obligations rather than upgrading their consequence into an immediate order.
+  const nativeReleasePolicy = classifySemanticText({ promptText: original, targetFile }).releasePolicy;
+  const deferredSpans = new Set(spans.filter(span => span.context === 'instruction'
+    && span.polarity === 'affirmative' && span.condition
+    && /^(?:[-*+•\d.)\s]*)(?:if|neu|only if|only when)\b/.test(foldIntent(span.raw))
+    && !nativeReleasePolicy && !VERIFICATION_GOAL.test(foldIntent(original))
+    && !defectRepairBranches(foldIntent(span.raw)).length
+    && ordersPublicationText(foldIntent(span.raw).replace(/^[^,]*,\s*/, ''))));
+  // An explicit alternative links both consequences. Keep the unconditional
+  // review prefix, but do not require a repair before its review has found one.
+  const alternatives = spans.filter(span => span.condition?.startsWith('otherwise:'));
+  for (const alternative of alternatives) {
+    const preceding = spans[spans.indexOf(alternative) - 1];
+    if (preceding.context === 'instruction' && preceding.polarity === 'affirmative'
+      && alternative.context === 'instruction' && alternative.polarity === 'affirmative') {
+      deferredSpans.add(preceding);
+      deferredSpans.add(alternative);
+    }
+  }
+  for (const span of [...spans].reverse()) {
+    const approvalPending = span.condition && /\b(?:approv\w*|permission|authori[sz]\w*)\b/.test(span.condition);
+    if (span.context === 'quotation' || span.context === 'description' || approvalPending || deferredSpans.has(span)) {
+      // Retain the prefix before a comma-introduced postfix repair condition.
+      // Leading conditions and otherwise consequences are masked in full.
+      const prefix = deferredSpans.has(span) && !/^(?:\s*)(?:if|neu|only if|only when|otherwise)\b/.test(foldIntent(span.raw))
+        ? span.raw.match(/^[^,]*,/)?.[0] || '' : '';
+      const masked = prefix + span.raw.slice(prefix.length).replace(/[^\r\n]/g, ' ');
+      semanticInput = semanticInput.slice(0, span.start) + masked + semanticInput.slice(span.end);
+    }
+  }
+  const semantic = classifySemanticText({ promptText: semanticInput.replace(/\r\n?/g, '\n'), targetFile });
+  const actions = spans.flatMap((span, spanIndex) => {
+    const text = foldIntent(span.raw);
+    // Categories are independent obligations, not mutually exclusive labels. Keep
+    // pending actions in the inventory even though no predicate or permission is proven.
+    const categories = [
+      ['publication', /\b(?:publish|npm publish|phat hanh)\b/],
+      ['git', /\bgit\s+(?:push|commit|tag|reset|clean|merge|rebase)\b|\b(?:commit|tag|push)(?:\/(?:commit|tag|publish|push))+\b/],
+      ['runtime', /\b(?:restart|deploy|redeploy)\b/],
+      ['source', /\b(?:implement|fix|modify|edit|sua|refactor|apply)\b/],
+      ['verification', /\b(?:verify|test|rerun|confirm|validate)\b/],
+    ].filter(([, pattern]) => pattern.test(text)).map(([category]) => category);
+    const sourceTarget = span.raw.match(/\b((?:[\w.-]+\/)+[\w.-]+\.[cm]?[jt]sx?)\b/)?.[1];
+    return categories.map(category => {
+      const permittedBySemantic = category === 'publication' ? semantic.publication === true
+        : category === 'git' || category === 'runtime' ? Boolean(semantic.operationGoal)
+        : category === 'source' ? ['CODE_IMPLEMENTATION', 'MIXED', 'CONFIGURATION'].includes(semantic.taskKind) : true;
+      return { spanIndex, category, target: category === 'source' ? sourceTarget || targetFile || null : semantic.operationGoal || null,
+        condition: span.condition, authorization: 'not-evaluated',
+        active: span.activation === 'eligible' && permittedBySemantic,
+        explanation: span.activation === 'eligible' ? 'canonical classification of current owner prompt' : `${span.context}/${span.polarity}/${span.activation}` };
+    });
+  });
+  const conditionalObligations = actions.filter(action => deferredSpans.has(spans[action.spanIndex])
+    && ['publication', 'git', 'runtime', 'source'].includes(action.category))
+    .map(action => ({ ...action, activation: 'pending' }));
+  if (conditionalObligations.length) {
+    semantic.conditionalObligations = conditionalObligations;
+    if (semantic.taskKind === 'READ_ONLY') {
+      delete semantic.statusReport;
+      semantic.verificationOnly = true;
+    }
+  }
+  return { engineVersion: SEMANTIC_ENGINE_VERSION, identity: { taskInstanceId, sessionId }, original, spans, actions, semantic };
+}
+const PUBLISH_ORDER_NEGATOR = /\b(?:do not|don't|dont|never|without|not yet|no|not|avoid|skip|exclud\w*|forbid\w*|prohibit\w*|khong|chua)\b|--dry-run/;
+const PUBLISH_ORDER_IMPERATIVE = /^(?:please\s+|just\s+|now\s+|also\s+)*(?:run|do|execute|perform|go|ship|publish|release|push|tag|commit|verify|make|cut|chay)\b/;
+const PUBLISH_ORDER_HEADER = /prohibit|forbidden|out of scope|non-goal|scope control/;
+function defectRepairBranches(text) {
+  return [...text.matchAll(/(?:^|\n|\.\s+)[ \t]*(?:[-*]|\d+[.)])?\s*((?:neu\s+(?:gap|phat hien|tim thay|co)|if\b)[^.!?]*(?:\.(?!\w)|$))/g)]
+    .map((match) => match[1])
+    .filter((branch) => !/\n\s*\n/.test(branch)
+      && /^(?:neu\s+(?:gap|phat hien|tim thay|co)\s+(?:bug|loi)|if\s+[^,\n]*(?:bug|defect|error)\b)/.test(branch)
+      && /\b(?:sua|fix|repair)\b/.test(branch));
+}
+
+function publicationScope(promptText = '') {
+  const plain = String(promptText).normalize('NFC')
+    .replace(/\bdùng\b/giu, 'su dung').replace(/đừng/giu, 'khong')
+    .replace(/(^|[\n;.]\s*)([ \t]*(?:[-*+•]|\d+[.)])?[ \t]*)dung(?=\s+(?:publish|release|npm|git|run|fix|sua)\b)/gi, '$1$2khong')
+    .normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[^]*?```|~~~[^]*?~~~/g, '').replace(/^[ \t]*>.*$/gm, '')
+    .replace(/[“"][^”"\n]*[”"]|‘[^’\n]*’/g, '')
+    .replace(/\b(?:not a request to|khong phai yeu cau)\b[^.;\n]*(?=[.;\n]|$)/g, 'review')
+    .replace(/^([ \t]*(?:[-*+•]|\d+[.)])?[ \t]*)(?:(?:hay|vui long|xin)\s+)+/gm, '$1')
+    .replace(/\bout of scope\s*:[^.;\n]*/g, 'review')
+    .replace(/(?:^|(?<=[.;\n]))\s*(?:to\s+[^.;\n]{0,80},\s*you can\s+|(?:the\s+)?reviewer\s+suggested\s*:)\s*[^.;\n]*(?=[.;\n]|$)/g, '');
+  let section = null;
+  let review = false;
+  let described = false;
+  let reproduction = false;
+  let exampleIndent = null;
+  const lines = [];
+  for (const line of plain.split('\n')) {
+    if (!line.trim()) { lines.push(''); continue; }
+    const label = line.replace(/^[\s#*\d.)-]+/, '').trim();
+    const bullet = /^\s*(?:[-*+•]|\d+[.)]|[a-z][.)])\s+/.test(line);
+    const execution = /^(?:(?:please|now|then)\s+)*(?:execute|perform|follow|run|thuc hien|chay)\b.*\b(?:steps?|workflow|process|instructions|cac buoc)\b/.test(label)
+      || /^(?:instructions|commands|yeu cau)\s*:/.test(label);
+    if (/^\s*\d+[.)]\s+release\b.*\b(?:bat buoc|mandatory)\b/.test(line)) { section = 'execute'; lines.push('instructions:'); continue; }
+    if (execution) section = 'execute';
+    else if (section === 'execute' && /:\s*$/.test(label)) section = 'execute';
+    else if (/^(?:do not|prohibitions?|forbidden)\s*:\s*$/.test(label)) section = 'prohibit';
+    else if (section === 'prohibit' && bullet) { lines.push(`do not ${label}`); continue; }
+    else if (/^(?:distinguish|compare)(?:\s+between)?\s*:\s*$/.test(label)) { section = 'describe'; lines.push('review distinctions:'); continue; }
+    else if (/\b(?:review|audit|inspect|checklist)\b.*:\s*$/.test(label)
+      || (review && (/\b(?:steps?|usage|process|workflow)\s*:\s*$/.test(label)
+        || /^\s*[a-z][.)]\s+[^\n]*:\s*$/.test(line)))) section = 'describe';
+    if (/^(?:the\s+)?(?:docs?|documentation|manual|readme)\s+(?:says?|states?|shows?|describes?)\s*:/.test(label)) {
+      lines.push('review described documentation');
+      continue;
+    }
+    if (section === 'describe' && bullet && !execution) continue;
+    if (!bullet && !/:\s*$/.test(label)) section = null;
+    if (/\b(?:review|audit|read[_ -]*only)\b/.test(label)) review = true;
+    if (/\b(?:false negatives?|findings|regression matrix|test matrix)\s*:\s*$/.test(label)
+      || /^(?:exact\s+)?(?:(?:positive|negative)\s+)?reproductions\b[^:]*:\s*$/.test(label)) { section = 'describe'; lines.push('review described context'); continue; }
+    if (label === 'reproduction:') { reproduction = true; continue; }
+    if (reproduction) { reproduction = false; continue; }
+    const indent = line.search(/\S/);
+    if (exampleIndent !== null && indent > exampleIndent && bullet) continue;
+    exampleIndent = null;
+    if (/^(?:them (?:positive|negative) fixtures|nhung van nhan dung imperative that)\s*:/.test(label)) {
+      exampleIndent = indent;
+      continue;
+    }
+    if (/^\s*\d+[.)]\s+release\b.*—\s*(?:dieu kien|prerequisites)\b/.test(line)) continue;
+    if (/\b(?:prompt|request|task)\b[^.;\n]*\b(?:prohibit\w*|cam)\b/.test(label)) { lines.push(`do not ${label}`); continue; }
+    const example = /^(?:(?:cac|the)\s+)?(?:(?:positive|negative|test)\s+(?:cases?|inputs?|examples?|controls?)|examples?|inputs?|observed|actual|expected|bug report|confirm|historical (?:evidence|input)|vi du)\s*:|^required replay matrix\s*$/.test(label);
+    if (example) { described = /:\s*$|^required replay matrix\s*$/.test(label); continue; }
+    if (described && bullet) continue;
+    if (!bullet) described = false;
+    if (/^(?:input|observed|actual|expected|bug description|history|checklist)\s*:/.test(label)) continue;
+    // Inspecting an operation names its subject, not an execution order. Keep later clauses active.
+    if (/^(?:check|inspect|review|audit|compare)\s+git\b/.test(label)) {
+      lines.push(line.replace(/^[^.;\n]*?(?=\s+(?:then|but|instead)\s+|\s+and\s+(?:run|execute|implement|modify|edit|fix|publish)\b|[.;\n]|$)/, 'review subject'));
+      continue;
+    }
+    lines.push(line);
+  }
+  const text = lines.join('\n');
+  let prohibited = false;
+  let prohibitionBlock = false;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    const bullet = /^\s*(?:[-*•]|\d+[.)])\s+/.test(line);
+    if (!bullet) prohibitionBlock = PUBLISH_ORDER_NEGATOR.test(line) && /:\s*$/.test(line);
+    for (const clause of line.split(/;|\.\s+|\bthen\b|\bbut\b|\binstead\b/)) {
+      let negated = bullet && prohibitionBlock;
+      for (const raw of clause.split(/,|\band\b|\bor\b|\bnor\b/)) {
+        const item = raw.replace(/^[\s*•-]+/, '').trim();
+        if (PUBLISH_ORDER_NEGATOR.test(item)) negated = true;
+        else if (/^(?:please\s+|now\s+|also\s+)*(?:run|execute|perform|chay)\s+\S/.test(item)) negated = false;
+        if (negated && /\b(?:release|publish|publication)\b/.test(item)) prohibited = true;
+      }
+    }
+  }
+  return { text, prohibited };
+}
+
+function ordersPublication(promptText = '') {
+  return analyzeTaskIntent({ promptText }).semantic.publication === true;
+}
+
+function ordersPublicationText(promptText = '') {
+  let active = publicationScope(promptText).text.replace(/```[^]*?```|~~~[^]*?~~~/g, '')
+    .replace(/^[ \t]*>.*$/gm, '').replace(/[“"][^”"\n]*[”"]|‘[^’\n]*’/g, '');
+  for (const branch of defectRepairBranches(active)) active = active.replace(branch, '');
+  let ordered = false;
+  let blockNegated = false;
+  for (const line of active.split('\n')) {
+    const bullet = /^\s*(?:[-*\u2022]|\d+[.)])\s+/.test(line);
+    if (!line.trim()) { blockNegated = false; continue; }
+    if (!bullet) blockNegated = line.trim().length <= 80 && (PUBLISH_ORDER_NEGATOR.test(line) || PUBLISH_ORDER_HEADER.test(line)) && /:\s*$|^[^.]{0,40}$/.test(line.trim()) && !/\bnpm\s+publish\b/.test(line);
+    for (const sentence of line.split(/\s*;\s*|\.\s+|\.$/)) {
+      for (const hard of sentence.split(/\bthen\b|\bbut\b|\binstead\b/)) {
+        let negated = bullet && blockNegated;
+        for (const raw of hard.split(/,|\band\b|\bor\b|\bnor\b/)) {
+          const item = raw.replace(/^[\s\-*\u2022]+|^\d+[.)]\s*/g, '').trim();
+          if (PUBLISH_ORDER_NEGATOR.test(item)) negated = true;
+          else if (/^(?:please\s+|now\s+|also\s+)*(?:run|execute|perform|chay)\s+\S/.test(item)) negated = false;
+          const commandItem = item.replace(/^(?:please|just|now|also|then)\s+/, '');
+          const publication = /\bnpm\s+publish\b/.test(commandItem) && /^(?:npm\s+publish|run|do|execute|perform|go|ship|publish|release|push|tag|commit|verify|make|cut|chay)\b/.test(commandItem);
+          const releaseOrder = /^(?:please\s+|just\s+|now\s+|also\s+)*(?:release|ship|publish)\s+(?!instructions?\b|obligations?\b|policies\b|boundary\b|safety\b|progress\b|candidate\s+review\b|readiness\b|verifier\b|verification\b|evidence\b|policy\b|intent\b|notes\b|terminology\b)\S/.test(item);
+          const politeItem = item.replace(/^(?:(?:please|just|now|also|then|vui long|hay)\s+)+/, '');
+          const viPublish = /^(?:(?:su dung|phat hanh bang)\s+`?npm\s+publish\b|(?:dua|phat hanh|xuat ban|deploy|day)\b(?:[^.;\n]|\.(?=\d)){0,60}\b(?:len|to|vao)\s+npm\b)/.test(politeItem);
+          if (!negated && (releaseOrder || viPublish || (publication && (
+            (/^npm\s+publish\b/.test(politeItem) && (/^(?:[\s*•-]|\d+[.)])*(?:(?:please|just|now|also)\s+)*(?:npm\s+publish|run|execute|perform|commit|push|tag)\b/.test(hard.trim()) || /\bcontinue the release workflow:/.test(hard))) || PUBLISH_ORDER_IMPERATIVE.test(item)
+            || /\b(?:chay|run)\s+`?npm\s+publish\b/.test(item)
+            || /continue the release workflow:/.test(item))))) ordered = true;
+        }
+      }
+    }
+  }
+  return ordered;
+}
+
+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');
+    for (const clause of actionable) {
+      const bare = clause.match(GIT_ORDER_LEAD);
+      if (bare) verbs.push(bare[1]);
+    }
+    goal.requiredTargets = [...new Set(verbs)];
+    goal.check = /\bfsck\b/.test(text) ? 'fsck' : /\bdiff\s+--check\b/.test(text) ? 'diff-check' : null;
+    if (actionable.some((clause) => PRIVATE_ORDER.test(String(clause).replace(/"[^"\n]*"|`[^`\n]*`/g, ' ')))) goal.visibility = 'PRIVATE';
+    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;
+}
+
+const NON_ORDER_VERBS = 'implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|restart|sua|viet|chinh|them|tao|xoa';
+const VERIFICATION_GOAL = /(?:^|\n)[ \t*#_-]*(?:muc tieu|goal|purpose|objective)\s*:[^\n]*\b(?:xac nhan|verify|confirm|kiem tra|validate|double-?check|re-?run)\b/;
+const CONDITIONAL_BRANCH = /(?:^|\n|\.\s+)[ \t]*(?:\d+[.)]\s*)?(?:neu\s+(?:phat hien\s+(?:false-block|loi|bug|defect)|co\s+(?:source fix|sua doi))|if\s+(?:(?:a\s+)?(?:bug|defect|failure)\s+is\s+found|(?:you\s+)?find\s+(?:a\s+)?(?:bug|defect)))\b[^\n]*?(?=\.\s+|$|\n)/g;
+const GOAL_LABEL = /\b(?:muc tieu|goal|purpose|objective)\s*:/g;
+const DISPOSABLE_SETUP = /\b(?:tao|create)\s+(?:mot\s+)?(?:project|du an)\s+(?:thu nghiem|test|disposable|doc lap)\b(?:\s+(?:doc lap|independent))?/g;
+const noVerbList = () => new RegExp(`\\bno\\s+(?:${ORDER_VERBS})\\b(?:\\s*,\\s*(?:${ORDER_VERBS})\\b)*`, 'g');
+function neutralizeNonOrders(text) {
+  let source = publicationScope(text).text.replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  if (VERIFICATION_GOAL.test(source)) source = source.replace(GOAL_LABEL, ' ').replace(CONDITIONAL_BRANCH, '\n').replace(DISPOSABLE_SETUP, ' ');
+  // A labeled goal/acceptance span enumerates desired end states, so it is an order only when one of its own
+  // sentence fragments is imperative ("goal: ship it, then update the docs" orders; "goal: clean install and
+  // normal ukit update pass" does not — "update" there is a noun inside the acceptance criterion).
+  source = source.replace(/(^|\n|[.;]\s[ \t]*)([ \t*#_-]*(?:(?:final\s+)?(?:product\s+)?(?:muc tieu|goal|purpose|objective|acceptance criteria|tieu chi)\s*:))([^\n]*)/g,
+    (m, pre, label, content) => {
+      const frags = content.split(/\s*(?:[;,.]|\band\b|\bor\b|\bthen\b|\bva\b)\s*/).filter(Boolean);
+      return frags.some((f) => IMPERATIVE_ORDER.test(f) || MODAL_ORDER.test(f)) ? m : pre + label;
+    });
+  source = source
+    .replace(/\bno\s+git\s+(?:push|tag)\b(?:\s*\/\s*tag\b)?/g, ' ')
+    .replace(/\brelease\s+verifier\b/g, 'verification topic')
+    .replace(/\b(?:but|however)\s+(?=(?:run|execute|implement|modify|edit)\b)/g, '; ')
+    .replace(/\b(?:add|create|write)\s+(?:bounded\s+)?(?:independent\s+)?(?:adversarial\s+)?(?:replay\s+)?(?:variants|cases|tests|fixtures|evidence)\s+in\s+scratch\s+only\b/g, 'review replay');
+  const publicationList = '(?:ci|commit|push|tag|release|(?:npm\\s+)?publish)';
+  source = source.replace(new RegExp(`\\b(?:no|forbidden|prohibited|banned)\\s*:?\\s+${publicationList}\\b(?:\\s*(?:,|and|or)\\s*${publicationList}\\b)*`, 'g'), ' ');
+  return source.replace(noVerbList(), ' ')
+    .replace(/\brelease-(?:publication|verification)\b|\brelease\s+(?:instructions?|authorization|obligations?|policies|readiness)\b/g, 'publication topic')
+    .replace(/\brelease\s+(?:safety|verification\s+plan)\b/g, 'publication topic')
+    .replace(/^[ \t]*[-*+•][ \t]*owner\s+yeu\s+cau\b[^\n]*/gm, ' ')
+    .replace(/^([ \t]*[-*+•][ \t]*)release\s+progress\s+reporter(?=[ \t]*(?:,|$))/gm, '$1progress reporter')
+    .replace(/^[ \t]*(?:[-*+\u2022]|\d+[.)])[ \t]*(?:negative|positive)\s+controls?\b[^\n]*(?:\n(?![ \t]*(?:[-*+\u2022]|\d+[.)])|[ \t]*\n)[^\n]*)*/gm, ' ')
+    .replace(/(?:^|(?<=[.;][ \t]))[^.;\n]*\b(?:khong\s+(?:cho\s+phep|duoc|lam)|(?:does|do|did|is|are)\s+not\s+(?:allow|permit|authori[sz]e)\w*|not\s+(?:allowed|permitted|authori[sz]ed)|prohibitions?|prohibited(?:\s+actions?)?|forbidden(?:\s+actions?)?|banned|must\s+not\s+do)\s*:[ \t]*(?:\n[ \t]*(?:[-*+\u2022]|\d+[.)])[^\n]*)+/gm, ' ')
+    .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|shall\\s+not)\\s+[^.;\\n]*?(?=\\s+(?:and|va)\\s+(?:${NON_ORDER_VERBS})\\b|\\s+(?:but|nhung|then|however)\\b|[.;\\n]|$)`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:(?:tuyet\\s+doi\\s+)?khong|chua)\\s+[^.;\\n]*?(?=\\s+(?:nhung|tuy nhien)\\b|[.;\\n]|$)`, 'g'), ' ')
+    .replace(/"[^"\n]*\s[^"\n]*"|`[^`\n]*\s[^`\n]*`|\u201c[^\u201d\n]*\u201d/g, ' ')
+    .replace(/\b(?:uu tien|prefer(?:red)?)\s+(?:a\s+|an\s+)?(?:configuration|config|cau hinh)\s+(?:change|changes|update|thay doi)\b/g, ' ')
+    .replace(/\b(?:neu\s+(?:chi\s+)?(?:phai|can|thieu|khong du|bang chung chua du)(?![^.;\n]*\b(?:restart|deploy|xoa|delete|remove|cancel)\b)|if\s+(?:needed|necessary|required|evidence is insufficient))\b[^.;\n]*/g, ' ')
+    .replace(/[^.;\n]*\b(?:nao|gi|sao|the nao|bao nhieu)\b[^.;\n]*\?/g, ' ')
+    .replace(/\bchinh\s+(?:xac|sach)\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b|\b(?:diem|cho|muc|phan)\s+(?:phai|can|nen)\s+(?:sua|fix)\b/g, ' ')
+    .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
+    .replace(/\bwrite\s+permission\b/g, 'permission')
+    .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
+    .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ')
+    .replace(/(?:^|[\n.;])[ \t]*(?:[-*+•]|\d+[.)])?[ \t]*(?:outputs?|reports?|deliverables?|each|lists?|includes?|fields?|format|sections?|columns?)(?:\s+\w+){0,3}?\s*:(?:[^\n.;]|\.(?=\w))*/g,
+      (span, offset, whole) => {
+        const fixNouns = /\bfix(?:es)?(?:\s+applied\b|\s+(?:directions?|lists?|plans?|suggestions?|proposals?|items?|entries?|notes?|findings?|acceptance|recommendations?)\b)(?=\s*(?:,|$))|\bfixes\b(?=\s*(?:,|$))/g;
+        const residual = span.replace(fixNouns, ' ');
+        if (residual === span) return span;
+        if (new RegExp(`\\b(?:then|${NON_ORDER_VERBS}|${ORDER_VERBS})\\b`).test(residual)) return span;
+        const tail = whole.slice(offset + span.length);
+        if (tail.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/).some((clause) => CLAUSE_ORDER_LEAD.test(clause))) return span;
+        return residual;
+      });
+}
+
+const READ_ONLY_DECLARATION = /\breviewer\s*[,—:-]?\s+read[\s_-]*only\b|\bread[\s_-]*only(?:\s+\w+){0,3}?\s+(?:audit|investigation|review|analysis|inspection|inventory|task|request|session|pass|check|diagnos\w+|verification|forensics?|reports?)\b|(?:^|\n)[\s*#>_-]*read[\s_-]*only\s*[.:!—-]|\b(?:audit|investigation|review|analysis|inventory)[\s-]*only\b|[(,]\s*read[\s_-]*only\s*[).]|\bchi\s+(?:doc|audit|kiem tra|kiem ke|phan tich|dieu tra)\b|\bkhong\s+sua\b|\b(?:make|with)\s+no\s+(?:source\s+|code\s+|file\s+)?(?:changes|edits|modifications)\b|\b(?:do\s+not|don't|dont|never)\s+(?:\w+\s+){0,2}edits?\b/;
+const ORDER_VERBS = 'implement|fix|apply|refactor|modify|edit|write|update|add|create|build|install|deploy|redeploy|restart|push|commit|rename|remove|delete|replace|change|sua|viet|chinh|them|bo sung|tao|xoa|enable|disable|set|toggle|configure|migrate|upgrade|publish|release|trien khai|khoi dong lai|(?:run|execute)\\s+(?:git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)|(?:npm|yarn)\\s+publish)|git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)';
+const IMPERATIVE_ORDER = new RegExp(`^(?:[-*+\\u2022>\\d.)\\s]*)(?:(?:please|hay|vui long|now|also|first|then)\\s+)*(?:${ORDER_VERBS})\\b\\s+\\S`);
+const MODAL_ORDER = new RegExp(`\\b(?:please|hay|vui long|need to|needs to|must|should|want(?:\\s+you)? to|toi muon|can phai|yeu cau)\\s+(?:[\\w-]+\\s+){0,2}(?:${ORDER_VERBS})\\b`);
+function hasExplicitOrder(clauses) {
+  return clauses.some((clause) => IMPERATIVE_ORDER.test(clause) || MODAL_ORDER.test(clause));
+}
+const CLAUSE_ORDER_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:commit|push(?!\s+back\b)|publish|release(?!\s+(?:notes?|process|works?|plan|candidate|checklist)\b)|apply|(?:run|execute)\s+(?:the\s+)?(?:implementation|build|migration|deploy(?:ment)?|publish|release|script|command))\b/;
+const ADDITIVE_ORDER_LEAD = /^(?:[-*+\u2022>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:add|create|build|implement|them|bo sung|tao)\s+(?=[^.;\n]{0,80}?(?:\b(?:tests?|checks?|e2e|specs?|fixtures?|files?|modules?|functions?|features?|endpoints?|handlers?|resolvers?|parsers?|helpers?|scripts?|hooks?|options?|flags?|source|code)\b|\.[cm]?[jt]sx?\b))/;
+function ordersChangeAcrossClauses(clauses) {
+  return clauses.some((clause) => CLAUSE_ORDER_LEAD.test(clause));
+}
+const GIT_ORDER_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|chi|now|also|first|then)\s+)*(commit|push(?!\s+back\b))\b/;
+const PRIVATE_ORDER = /\b(?:make|set|keep|switch|change|lam|giu|chuyen|dat)\b[^.;\n]{0,40}\b(?:private|rieng tu|che do private)\b|\bvisibility\s+(?:to\s+|sang\s+)?private\b|\b(?:create|tao|push|publish|day)\b[^.;\n]{0,40}\b(?:private\s+(?:github\s+|git\s+)?(?:repo|repos|repository|remote)|(?:repo|repos|repository|remote)\s+(?:github\s+)?private)\b|\b(?:to|vao|len|tren)\s+(?:the\s+)?private\s+(?:repo|repository|remote)\b/;
+function declaredReadOnly(promptText, releasePolicy) {
+  if (releasePolicy) return false;
+  const plain = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  if (!READ_ONLY_DECLARATION.test(plain)) return false;
+  const text = neutralizeNonOrders(plain);
+  const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0])
+    .filter((clause) => !/\b(?:do not|don't|never|khong)\b|^[\s*+•>\d.)-]*(?:(?:vui long|xin|hay|please)\s+)*dung\b/.test(clause));
+  return /\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|investigation|inventory|forensic|root cause|kiem tra|kiem ke|phan tich|dieu tra|doc log|tim hieu)\b/.test(text.replace(/\bread[\s_-]*only\b/g, 'task mode'))
+    && !hasExplicitOrder(clauses)
+    && !ordersChangeAcrossClauses(clauses);
+}
+
+const VERIFY_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:(?:keep|continue|tiep tuc)\s+)?(?:verify|re-?run|confirm|xac nhan|validate|double-?check|wait(?:ing)?|monitor|watch|cho(?=\s+(?:dung\s+)?(?:job|verifier|build|test|suite|gate|ci|run|task|ket qua|xong|output)\b))\b/;
+const CHANGE_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:make|rebuild|redo|rewrite|restore|revert|correct|clean|patch|resolve|ensure|run(?!(?=[^.]*\b(?:tests?|suite|gate|checks?|lint|typecheck|pilot|smoke|e2e|verif\w*|vitest|jest|audit)\b)))\b/;
+function isVerificationOnlyRequest(promptText) {
+  const plain = String(promptText ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  const clauses = neutralizeNonOrders(plain).split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b|\broi\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0]);
+  return clauses.some((clause) => VERIFY_LEAD.test(clause)) && !hasExplicitOrder(clauses)
+    && !clauses.some((clause) => CHANGE_LEAD.test(clause));
+}
+
+function neutralizeBannedLists(text) {
+  const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin|commit|push)';
+  const LIST = `${OP}(?:\\s*(?:,|/|\\band\\b|\\bor\\b|\\bva\\b|\\bhoac\\b|\\balso\\b)\\s*${OP})*`;
+  const BAN = '(?:bi\\s+(?:cam|chan)|forbidden|prohibited|banned|not\\s+allowed|not\\s+permitted|disallowed)';
+  const LIFT = /\b(?:was|were|previously|before|formerly|no\s+longer|even\s+though|although|though|now\s+allows?|now\s+permits?|owner\s+allows?|khong\s+bi|da\s+duoc\s+phep|except)\b/;
+  const span = new RegExp(`\\b(?:(?:forbidden|prohibited|banned)\\s*:\\s*${LIST}|${LIST}\\s*:?\\s*(?:(?:is|are|remains?|van|con)\\s+)?(?:both\\s+)?${BAN})\\b`, 'g');
+  return text.replace(span, (m, offset, whole) => {
+    const start = Math.max(whole.lastIndexOf('.', offset), whole.lastIndexOf(';', offset), whole.lastIndexOf('\n', offset)) + 1;
+    const stops = [whole.indexOf('.', offset + m.length), whole.indexOf(';', offset + m.length), whole.indexOf('\n', offset + m.length)].filter((i) => i >= 0);
+    const end = stops.length ? Math.min(...stops) : whole.length;
+    return LIFT.test(whole.slice(start, end)) ? m : ' ';
+  });
+}
+
+function classifyTaskSemantics(input = {}) {
+  return analyzeTaskIntent(input).semantic;
+}
+
+function actionableClauses(promptText) {
+  const text = neutralizeBannedLists(neutralizeNonOrders(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)\b|^[\s*+•>\d.)-]*(?:(?:vui long|xin|hay|please)\s+)*dung\b/.test(clause)
+    && !/^[\s*+•>\d.)-]*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause)
+    // A fragment led by a subordinator continues the previous clause's predicate ("…, including source
+    // fixes F-3" is prose about the past, never a new imperative).
+    && !/^[\s*+•>\d.)-]*(?:including|such as|e\.g\.|i\.e\.|via|per)\b/.test(clause));
+  return { text, clauses, actionable };
+}
+
+// Positive additive-order signal (add/create/bo sung ... <code or test artifact>) for callers that must not treat the
+// classifier's CODE_IMPLEMENTATION default as an order (a bare "ok" is that default, not a change order).
+function ordersAdditiveChange(promptText = '') {
+  return actionableClauses(publicationScope(promptText).text).actionable.some((clause) => ADDITIVE_ORDER_LEAD.test(clause));
+}
+
+function classifySemanticText({ promptText = '', targetFile = '' } = {}) {
+  promptText = publicationScope(promptText).text;
+  const releaseText = String(promptText).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
+  const preflight = releaseText.match(/\b(?:yarn\s+release:verify|npm\s+run\s+release:verify)\b/)?.[0];
+  const releasePolicy = preflight && /\b(?:if|neu|only when|only if)\b[^\n.;]*(?:pass|go)\b[^\n.;]*(?:release|publish)\b/.test(releaseText)
+    && /\b(?:fail|no-go)\b[^\n.;]*(?:do not publish|don't publish|no publish|khong publish|khong npm publish)\b/.test(releaseText)
+    ? { kind: 'conditional-release', preflight } : null;
+  const { text, clauses, actionable } = actionableClauses(promptText);
+  if (ordersPublicationText(promptText)) {
+    const implementation = hasExplicitOrder(clauses.filter((clause) => !/\b(?:release|publish)\b/.test(clause)));
+    const remaining = clauses.filter((clause) => !ordersPublicationText(clause) && !/\b(?:release|publish)\b/.test(clause)).join('; ');
+    const base = remaining.trim() ? classifySemanticText({ promptText: remaining, targetFile }) : {};
+    delete base.verificationOnly;
+    delete base.statusReport;
+    return { ...base, taskKind: implementation ? 'MIXED' : 'OPERATIONAL', publication: true, ...(releasePolicy ? { releasePolicy } : {}) };
+  }
+  if (!/[a-z0-9]/.test(text)) return { taskKind: 'READ_ONLY' };
+  if (declaredReadOnly(promptText, releasePolicy)) return { taskKind: 'READ_ONLY', ...(isVerificationOnlyRequest(promptText) ? { verificationOnly: true } : {}) };
+  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause)
+    && /\b(?:source|code|logic|scheduler|implementation|ma nguon)\b|\.[cm]?[jt]sx?\b/.test(clause));
+  const codeChangeVerb = actionable.some((clause) => !/^(?:run\s+|execute\s+)?git\s+/.test(clause) && /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
+  const reportArtifact = String(promptText).match(/(?:^|\s)((?:docs\/|reports\/)[A-Za-z0-9_./-]+\.(?:md|txt))(?=\s|[.,;:]|$)/)?.[1];
+  const documentation = !sourceOrder && !/\b(?:implement|fix|refactor|modify|edit|update|sua|chinh)\b/.test(actionable.join(' ')) && reportArtifact && actionable.some((clause) => /\b(?:write|create|save|viet|tao|luu)\b/.test(clause))
+    && /\b(?:report|bao cao|analysis|phan tich|document)\b/.test(text);
+  const hasOperationId = /\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/.test(text);
+  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);
+  const operationNotOrdered = (clause) => {
+    const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin|commit|push)';
+    const BAN = '(?:bi\\s+(?:cam|chan)|forbidden|prohibited|banned|not\\s+allowed|not\\s+permitted|disallowed)';
+    if (/\b(?:was|were|previously|before|formerly|no\s+longer|even\s+though|although|though|now\s+allows?|now\s+permits?|owner\s+allows?|khong\s+bi|da\s+duoc\s+phep|except)\b/.test(clause)) return false;
+    if (/^[\s*+•>\d.)-]*(?:production|prod|staging)\s+(?:restart|redeploy|deploy(?:ment)?)\s*$/.test(clause)) return true;
+    const gap = `(?:(?!\\b(?:which|that|who|where|when|if|and|but|then)\\b|${OP})[^.;,()\\-:]){0,40}?`;
+    const banAfter = new RegExp(`^${gap}\\b(?:(?:is|are|remains?|van|con)\\s+)?${BAN}\\b(?!\\s+(?:to|from)\\b)`);
+    const joined = new RegExp(`^\\s*(?:/|,|and|or|va|hoac)\\s*${OP}\\b`);
+    const bannedAfter = (rest) => {
+      if (banAfter.test(rest)) return true;
+      const j = joined.exec(rest);
+      return j ? bannedAfter(rest.slice(j[0].length)) : false;
+    };
+    const banBefore = /\b(?:forbidden|prohibited|banned)\s+(?:(?:production|prod)\s+)?$/;
+    let total = 0;
+    let banned = 0;
+    for (const match of clause.matchAll(new RegExp(`\\b${OP}\\b`, 'g'))) {
+      total += 1;
+      if (bannedAfter(clause.slice(match.index + match[0].length)) || banBefore.test(clause.slice(0, match.index))) banned += 1;
+    }
+    return total > 0 && banned === total;
+  };
+  const gitOperation = actionable.some((clause) => !operationNotOrdered(clause)
+    && (GIT_ORDER_LEAD.test(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) => !operationNotOrdered(clause) && /(?<!\b(?:process|crash|hard|soft|graceful|after|upon|during|across|following)\s)\b(?:restart|redeploy|deploy|khoi dong lai|trien khai\s+(?:len\s+)?(?:service|server|production|prod|staging|dich vu|may chu|moi truong))\b/.test(clause)
+    && !/\.[cm]?[jt]sx?\b/.test(clause) && !/\bgit\b/.test(clause));
+  const nativeDomain = cronOperation ? 'scheduled-job' : gitOperation !== runtimeOperation ? (gitOperation ? 'git-integrity' : 'service-runtime') : null;
+  const operation = Boolean(nativeDomain);
+  if (!releasePolicy && !operation && isVerificationOnlyRequest(promptText)) return { taskKind: 'READ_ONLY', verificationOnly: true };
+  const CONFIG_CHANGE_REPORT_CLAUSE = /\b(?:da|has|have|had|already)\s+(?:doi|thay doi|changed?|updated?)\b|\b(?:nao|gi|which|what|report|bao cao)\b[^.;]*?\b(?:doi|thay doi|changed?|updated?)\b/;
+  const CONFIG_MUTATION_VERB = /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi(?!\s+chieu\b)|bat(?!\s+dau\b)|tat(?!\s+ca\b)|chinh)\b/;
+  const CONFIG_NOUN = /\b(?:configuration|config|toggle|cau hinh)\b/;
+  const CONFIG_REPORT_FRAME = /^\s*(?:report|show|tell|list|describe|explain|summari[sz]e|bao cao|cho biet|liet ke|mo ta)\b/;
+  const CONFIG_QUESTION_FRAME_PREFIX = /\b(?:what|which|how|report|bao cao|nao|gi)\b/;
+  const config = !sourceOrder && actionable.some((clause) => {
+    if (!CONFIG_NOUN.test(clause) || !CONFIG_MUTATION_VERB.test(clause)) return false;
+    if (CONFIG_REPORT_FRAME.test(clause)) return false;
+    const verb = CONFIG_MUTATION_VERB.exec(clause);
+    if (CONFIG_QUESTION_FRAME_PREFIX.test(clause.slice(0, verb.index))) return false;
+    const noun = CONFIG_NOUN.exec(clause);
+    return !CONFIG_CHANGE_REPORT_CLAUSE.test(clause) || Boolean(noun && noun.index > verb.index);
+  });
+  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
+  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 ACTIONABLE_MUTATION_ORDER = /(?<!\b(?:what|which|how|nao|gi)\s)(?<!thay )\b(?:implement|fix(?:es)?|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/;
+  const configReportQuestion = !actionable.some((clause) => ACTIONABLE_MUTATION_ORDER.test(clause))
+    && actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh|tham so)\b/.test(clause)
+      && CONFIG_CHANGE_REPORT_CLAUSE.test(clause));
+  const statusReport = (configReportQuestion || (!mutationWord
+      && /\b(?:check|status|report|show|summari[sz]e|result|results|kiem tra|bao cao|trang thai|ket qua|da len chua)\b/.test(text)))
+    && !operation && !config;
+  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text.replace(/\bread[\s-]*only\b/g, ' ')) || statusReport)
+    // An additive imperative (add/create/build/them/bo sung/tao) leading its own clause is an implementation order even
+    // when a sibling clause only reviews or checks, provided its object is a code/test/check artifact (a report such as
+    // "create a timeline" stays read-only); descriptive mentions never lead a clause.
+    && !sourceOrder && !codeChangeVerb && !operation && !config && !ordersChangeAcrossClauses(actionable)
+    && !actionable.some((clause) => ADDITIVE_ORDER_LEAD.test(clause));
+  const taskKind = operation ? (sourceOrder || codeChangeVerb ? 'MIXED' : 'OPERATIONAL')
+    : config ? 'CONFIGURATION' : documentation ? 'DOCUMENTATION_OUTPUT' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
+  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
+  return { taskKind, ...(releasePolicy ? { releasePolicy } : {}), ...(documentation ? { reportArtifact } : {}), ...(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)
+        || actionable.some((clause) => /\b(?:delete|remove|cancel|xoa|huy)\b/.test(clause)
+          && /\b(?:if\s+(?:it\s+)?(?:still\s+)?exists|if\s+present|neu\s+(?:van\s+|con\s+)?ton tai)\b/.test(clause))
+        ? 'ensure-state' : 'execute-and-verify' } } : {}) };
+}
+
+function applyTaskSemantics(contract, semantic) {
+  const evidence = contract?.completionEvidence || [];
+  if (semantic.taskKind === 'READ_ONLY' && semantic.conditionalObligations?.length) {
+    return { ...(contract || {}), ...semantic, statusReport: false, completionEvidence: ['verification-evidence'] };
+  }
+  if (semantic.publication) return { ...(contract || {}), ...semantic, completionEvidence: semantic.taskKind === 'MIXED'
+    ? [...new Set([...evidence.filter((item) => item !== 'impact-evidence'), 'write-evidence', ...(semantic.operationGoal ? ['operation-verification'] : ['verification-evidence']), 'release-publication'])] : ['release-publication'] };
+  const operationOnly = semantic.taskKind === 'OPERATIONAL'
+    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
+  return { ...(contract || {}), ...semantic,
+    completionEvidence: semantic.taskKind === 'DOCUMENTATION_OUTPUT' ? ['report-artifact'] : operationOnly ? ['operation-verification']
+      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
+        : semantic.taskKind === 'READ_ONLY' && semantic.statusReport ? []
+        : semantic.taskKind === 'READ_ONLY' ? (semantic.verificationOnly ? ['verification-evidence'] : ['impact-evidence'])
+        // A routed contract owns the debt; an unrouted (informational/null) turn carries none, because
+        // CODE_IMPLEMENTATION is the classifier's default kind, not proof that a change was ordered.
+        : semantic.taskKind === 'CODE_IMPLEMENTATION' && contract ? [...new Set([...evidence, 'write-evidence', 'verification-evidence'])] : evidence };
+}
+// END GENERATED SEMANTIC ENGINE
   const STOPWORDS = new Set([
     'the', 'a', 'an', 'and', 'or', 'to', 'for', 'of', 'with', 'in', 'on', 'is', 'are',
     'this', 'that', 'it', 'as', 'by', 'be', 'use', 'using', 'implement', 'fix', 'task',
     'cần', 'và', 'là', 'cho', 'một', 'những', 'dùng',
   ]);
 
-  // BUG-C21-04: every fs call in this deadline-guarded block is async — a sync
-  // read/stat/scan on a stalled mount parks the event loop and the unref'd
-  // deadline above can never fire (orphan node grandchild).
   const fsp = fs.promises;
 
   async function pathExists(filePath) {
@@ -237,9 +755,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
   }
 
   async function writeJsonFileAtomic(filePath, text) {
-    // tmp+rename: readers see old-or-new, never a torn/half file. A truncated
-    // skill-router-state.json parses as `{}` downstream and completion-gate.sh then
-    // releases a premature Stop with no message — the mid-run silent-stop class.
     await ensureDir(filePath);
     const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
     try {
@@ -363,12 +878,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     };
   }
 
-  // TASK-004 (BL-006): shared route resolver — the same module route-task.mjs
-  // uses, so hook state and helper state compute identical rigor/fastPath/
-  // riskFloor/resumable/decision-shadow fields. Loaded lazily via pathToFileURL
-  // (cache-utils pattern); any load/derive failure degrades to null so routing
-  // never breaks over advisory fields. Path is resolved lazily because
-  // `projectRoot` is declared below (TDZ).
   let routeResolverModule = null;
   let routeResolverLoadAttempted = false;
   async function loadRouteResolver() {
@@ -386,9 +895,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     return routeResolverModule;
   }
 
-  // TASK-007 (BL-009): playbook registry — same lazy pathToFileURL pattern as
-  // the shared resolver. Loaded once per hook run; failure degrades to null so
-  // routing never blocks on playbook resolution.
   let playbookRegistryModule = null;
   let playbookRegistryLoadAttempted = false;
   async function loadPlaybookRegistry() {
@@ -406,9 +912,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     return playbookRegistryModule;
   }
 
-  // BL-019 (SPEC FR-001): measured tier module — same lazy pathToFileURL
-  // pattern. A missing module/failure degrades to null so the static map
-  // stays authoritative and routing never blocks on the artifact read.
   let tierSelectionModule = null;
   let tierSelectionLoadAttempted = false;
   async function loadTierSelection() {
@@ -426,8 +929,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     return tierSelectionModule;
   }
 
-  // Tier lane: who performs the edit for the routed task (worker hand-off vs inline) for the MAIN
-  // session's tier. Same lazy pattern; a missing module degrades to no tier lane (legacy behavior).
   let tierLaneModule = null;
   let tierLaneLoadAttempted = false;
   async function loadTierLane() {
@@ -444,8 +945,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     }
     return tierLaneModule;
   }
-  // The persisted `tierLane` is what the Stop-side playbook acceptance reads (delegationRequired);
-  // the printed lines are what tell the model to dispatch the worker and tag its prompt.
   function writeTierLaneLines(summary, taskId) {
     const lane = summary?.tierLane;
     if (!lane?.instruction) {
@@ -456,8 +955,6 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       process.stdout.write(`[ukit-skill-router] Handback: start each worker prompt with "[ukit-task ${taskId}]" so its result binds to this task\n`);
       const hostHarness = process.env.UKIT_HARNESS || 'claude-code';
       if (summary.playbookId === 'feature-implementation' && hostHarness !== 'claude-code') {
-        // omp/codex expose no agent identity to hooks: the gate cannot refuse orchestrator writes there,
-        // so say what is actually enforced instead of promising a refusal.
         process.stdout.write('[ukit-skill-router] Delegation required: dispatch the worker; do not implement inline. This host gives hooks no worker identity, so orchestrator writes are NOT refused and worker attribution is reported UNVERIFIED (never a full PASS). Verify with a bare runner command (no pipe/tail/grep) and read its exit status.\n');
       } else if (summary.playbookId === 'feature-implementation') {
         process.stdout.write('[ukit-skill-router] Delegation gate: source/test writes from this orchestrator (Edit/Write/Bash heredoc) are refused until a native Tier 2 worker has handed back; repeated attempts end the run BLOCKED. Verify with a bare runner command (no pipe/tail/grep) and read its exit status.\n');
@@ -1872,188 +2369,6 @@ 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.
-// P1-A (forensic false block): the clause splitter below cuts at commas, so a negation only reached the
-// FIRST item of an enumeration ("Do not implement fixes, modify source code, restart services, ...") and
-// the later items became actionable orders (MIXED + service-runtime). English negators now scope to the
-// sentence end (', and'/', or' continue the list; a bare 'and <verb>' or but/then starts a new clause);
-// Vietnamese negators scope to the sentence end as well. Noun uses of verbs ("write/verification advisory", "each proposed
-// fix", "state change") name things, not orders. Neutralised spans become blanks, never new orders.
-const NON_ORDER_VERBS = 'implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|restart|sua|viet|chinh|them|tao|xoa';
-// Declared verification purpose ("Mục tiêu: xác nhận ...", "Goal: verify ..."). Under that declaration a
-// conditional repair/release branch ("Nếu phát hiện lỗi ... sửa ...", "Neu co source fix ... publish") is a
-// branch the check MAY take, not an unconditional order, and disposable test-project setup ("Tạo project thử
-// nghiệm độc lập") is scaffolding of the check. Unconditional orders in the same request keep blocking.
-const VERIFICATION_GOAL = /(?:^|\n)[ \t*#_-]*(?:muc tieu|goal|purpose|objective)\s*:[^\n]*\b(?:xac nhan|verify|confirm|kiem tra|validate|double-?check|re-?run)\b/;
-const CONDITIONAL_BRANCH = /(?:^|\n|\.\s+)[ \t]*(?:\d+[.)]\s*)?(?:neu\s+(?:phat hien\s+(?:false-block|loi|bug|defect)|co\s+(?:source fix|sua doi))|if\s+(?:(?:a\s+)?(?:bug|defect|failure)\s+is\s+found|(?:you\s+)?find\s+(?:a\s+)?(?:bug|defect)))\b[^\n]*?(?=\.\s+|$|\n)/g;
-const GOAL_LABEL = /\b(?:muc tieu|goal|purpose|objective)\s*:/g;
-const DISPOSABLE_SETUP = /\b(?:tao|create)\s+(?:mot\s+)?(?:project|du an)\s+(?:thu nghiem|test|disposable|doc lap)\b(?:\s+(?:doc lap|independent))?/g;
-function neutralizeNonOrders(text) {
-  let source = String(text).replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
-  if (VERIFICATION_GOAL.test(source)) source = source.replace(GOAL_LABEL, ' ').replace(CONDITIONAL_BRANCH, '\n').replace(DISPOSABLE_SETUP, ' ');
-  return source
-    // A list item that DESCRIBES test cases ("Negative controls: yêu cầu thực sự chỉnh config/restart/deploy ...") is
-    // specification of the work, not an order; it runs to the next bullet or blank line.
-    .replace(/^[ \t]*(?:[-*+\u2022]|\d+[.)])[ \t]*(?:negative|positive)\s+controls?\b[^\n]*(?:\n(?![ \t]*(?:[-*+\u2022]|\d+[.)])|[ \t]*\n)[^\n]*)*/gm, ' ')
-    // A header that negates the list under it ("Authorization ... không cho phép:", "Prohibitions:", "not allowed:")
-    // makes every bullet an item of the prohibition, not an order.
-    .replace(/(?:^|(?<=[.;][ \t]))[^.;\n]*\b(?:khong\s+(?:cho\s+phep|duoc|lam)|(?:does|do|did|is|are)\s+not\s+(?:allow|permit|authori[sz]e)\w*|not\s+(?:allowed|permitted|authori[sz]ed)|prohibitions?|prohibited(?:\s+actions?)?|forbidden(?:\s+actions?)?|banned|must\s+not\s+do)\s*:[ \t]*(?:\n[ \t]*(?:[-*+\u2022]|\d+[.)])[^\n]*)+/gm, ' ')
-    .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|shall\\s+not)\\s+[^.;\\n]*?(?=(?<!,)\\s+(?:and|va)\\s+(?:${NON_ORDER_VERBS})\\b|\\s+(?:but|nhung|then|however)\\b|[.;\\n]|$)`, 'g'), ' ')
-    .replace(new RegExp(`\\b(?:khong|chua)\\s+[^.;\\n]*?(?=\\s+(?:nhung|tuy nhien)\\b|[.;\\n]|$)`, 'g'), ' ')
-    .replace(/"[^"\n]*\s[^"\n]*"|`[^`\n]*\s[^`\n]*`|\u201c[^\u201d\n]*\u201d/g, ' ')
-    .replace(/\b(?:uu tien|prefer(?:red)?)\s+(?:a\s+|an\s+)?(?:configuration|config|cau hinh)\s+(?:change|changes|update|thay doi)\b/g, ' ')
-    .replace(/\b(?:neu\s+(?:chi\s+)?(?:phai|can|thieu|khong du|bang chung chua du)(?![^.;\n]*\b(?:restart|deploy|xoa|delete|remove|cancel)\b)|if\s+(?:needed|necessary|required|evidence is insufficient))\b[^.;\n]*/g, ' ')
-    .replace(/[^.;\n]*\b(?:nao|gi|sao|the nao|bao nhieu)\b[^.;\n]*\?/g, ' ')
-    .replace(/\bchinh\s+(?:xac|sach)\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b|\b(?:diem|cho|muc|phan)\s+(?:phai|can|nen)\s+(?:sua|fix)\b/g, ' ')
-    .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
-    .replace(/\bwrite\s+permission\b/g, 'permission')
-    .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
-    .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ');
-}
-
-const ORDER_VERBS = 'implement|fix|apply|refactor|modify|edit|write|update|add|create|build|install|deploy|redeploy|restart|push|commit|rename|remove|delete|replace|change|sua|viet|chinh|them|tao|xoa|enable|disable|set|toggle|configure|migrate|upgrade|publish|release|trien khai|khoi dong lai|(?:run|execute)\\s+(?:git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)|(?:npm|yarn)\\s+publish)|git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)';
-const IMPERATIVE_ORDER = new RegExp(`^(?:[-*+\\u2022>\\d.)\\s]*)(?:(?:please|hay|vui long|now|also|first|then)\\s+)*(?:${ORDER_VERBS})\\b\\s+\\S`);
-const MODAL_ORDER = new RegExp(`\\b(?:please|hay|vui long|need to|needs to|must|should|want(?:\\s+you)? to|toi muon|can phai|yeu cau)\\s+(?:[\\w-]+\\s+){0,2}(?:${ORDER_VERBS})\\b`);
-function hasExplicitOrder(clauses) {
-  return clauses.some((clause) => IMPERATIVE_ORDER.test(clause) || MODAL_ORDER.test(clause));
-}
-// Verification-only request. Root cause of a false `write-evidence` block on a "verify / re-run /
-// confirm" prompt: the vocabulary scans counted nouns and compounds ("coordinator fix", "re-run",
-// "template/install", "source change") as mutation orders. Order is structural: a request whose
-// command-position verbs are verification verbs, with no explicit order (hasExplicitOrder) and no
-// change-leading clause, orders no change - it owes verification evidence, not a write.
-const VERIFY_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:verify|re-?run|confirm|xac nhan|validate|double-?check)\b/;
-const CHANGE_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:make|rebuild|redo|rewrite|restore|revert|correct|clean|patch|resolve|ensure|run(?!(?=[^.]*\b(?:tests?|suite|gate|checks?|lint|typecheck|pilot|smoke|e2e|verif\w*|vitest|jest|audit)\b)))\b/;
-function isVerificationOnlyRequest(promptText) {
-  const plain = String(promptText ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
-    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
-  const clauses = neutralizeNonOrders(plain).split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
-    .map((clause) => clause.split(/\bwithout\b/)[0]);
-  return clauses.some((clause) => VERIFY_LEAD.test(clause)) && !hasExplicitOrder(clauses)
-    && !clauses.some((clause) => CHANGE_LEAD.test(clause));
-}
-
-function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
-  // A named preflight and both explicit branches are required; a failed arbitrary test is not a release policy.
-  const releaseText = String(promptText).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
-  const preflight = releaseText.match(/\b(?:yarn\s+release:verify|npm\s+run\s+release:verify)\b/)?.[0];
-  const releasePolicy = preflight && /\b(?:if|neu|only when|only if)\b[^\n.;]*(?:pass|go)\b[^\n.;]*(?:release|publish)\b/.test(releaseText)
-    && /\b(?:fail|no-go)\b[^\n.;]*(?:do not publish|don't publish|no publish|khong publish|khong npm publish)\b/.test(releaseText)
-    ? { kind: 'conditional-release', preflight } : null;
-  const text = neutralizeNonOrders(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*/);
-  // Folded đúng (correctly) is also "dung"; only command-position đừng negates an order.
-  const actionable = clauses.map((clause) => clause.split(/\bwithout\b/)[0]).filter((clause) => !/\b(?:do not|don't|never|khong)\b|^[\s*+•>\d.)-]*(?:(?:vui long|xin|hay|please)\s+)*dung\b/.test(clause)
-    && !/^[\s*+•>\d.)-]*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
-  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause)
-    && /\b(?:source|code|logic|scheduler|implementation|ma nguon)\b|\.[cm]?[jt]sx?\b/.test(clause));
-  const codeChangeVerb = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
-  const reportArtifact = String(promptText).match(/(?:^|\s)((?:docs\/|reports\/)[A-Za-z0-9_./-]+\.(?:md|txt))(?=\s|[.,;:]|$)/)?.[1];
-  const documentation = !sourceOrder && !/\b(?:implement|fix|refactor|modify|edit|update|sua|chinh)\b/.test(actionable.join(' ')) && reportArtifact && actionable.some((clause) => /\b(?:write|create|save|viet|tao|luu)\b/.test(clause))
-    && /\b(?:report|bao cao|analysis|phan tich|document)\b/.test(text);
-  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));
-  // 'trien khai' is Vietnamese for both "deploy" and "implement": it orders a runtime operation only
-  // when it names a runtime target; bare it describes work ("Tier 3 truc tiep trien khai thay Tier 2").
-  // "restart"/"deploy" after a noun modifier ("process restart", "after redeploy") is a scenario, not an order.
-  const runtimeOperation = actionable.some((clause) => /(?<!\b(?:process|crash|hard|soft|graceful|after|upon|during|across|following)\s)\b(?:restart|redeploy|deploy|khoi dong lai|trien khai\s+(?:len\s+)?(?:service|server|production|prod|staging|dich vu|may chu|moi truong))\b/.test(clause)
-    && !/\.[cm]?[jt]sx?\b/.test(clause) && !/\bgit\b/.test(clause));
-  const nativeDomain = cronOperation ? 'scheduled-job' : gitOperation !== runtimeOperation ? (gitOperation ? 'git-integrity' : 'service-runtime') : null;
-  const operation = Boolean(nativeDomain);
-  // A verification-only request orders no change; a concrete operation order (cancel/restart/push) stays operational.
-  if (!releasePolicy && !operation && isVerificationOnlyRequest(promptText)) return { taskKind: 'READ_ONLY', verificationOnly: true };
-  // A config MENTION is not a config change: the same clause needs a mutation verb, and a
-  // request that also changes source/code is a coding task (config is part of its tests/fixtures).
-  // A DIAGNOSTIC report of past changes ("which parameters/configuration has changed, if any" /
-  // "tham so/cau hinh nao da thay doi, neu co") is a question about history, never an authorization
-  // to mutate: only a forward order ("change X to Y") stays a config mutation.
-  const CONFIG_CHANGE_REPORT_CLAUSE = /\b(?:da|has|have|had|already)\s+(?:doi|thay doi|changed?|updated?)\b|\b(?:nao|gi|which|what|report|bao cao)\b[^.;]*?\b(?:doi|thay doi|changed?|updated?)\b/;
-  // A relative past-change clause inside a FORWARD imperative ("Set the config that
-  // has changed to dark mode") names WHICH config — it does not make the sentence a
-  // report. The override holds only when the clause's FIRST mutation word precedes
-  // the config noun AND no reporting/question frame opens the clause or precedes
-  // that word: in "Report what change was made to the config" the mutation word is
-  // a question's noun, never an order.
-  const CONFIG_MUTATION_VERB = /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi(?!\s+chieu\b)|bat(?!\s+dau\b)|tat(?!\s+ca\b)|chinh)\b/;
-  const CONFIG_NOUN = /\b(?:configuration|config|toggle|cau hinh)\b/;
-  const CONFIG_REPORT_FRAME = /^\s*(?:report|show|tell|list|describe|explain|summari[sz]e|bao cao|cho biet|liet ke|mo ta)\b/;
-  const CONFIG_QUESTION_FRAME_PREFIX = /\b(?:what|which|how|report|bao cao|nao|gi)\b/;
-  const config = !sourceOrder && actionable.some((clause) => {
-    if (!CONFIG_NOUN.test(clause) || !CONFIG_MUTATION_VERB.test(clause)) return false;
-    if (CONFIG_REPORT_FRAME.test(clause)) return false;
-    const verb = CONFIG_MUTATION_VERB.exec(clause);
-    if (CONFIG_QUESTION_FRAME_PREFIX.test(clause.slice(0, verb.index))) return false;
-    const noun = CONFIG_NOUN.exec(clause);
-    return !CONFIG_CHANGE_REPORT_CLAUSE.test(clause) || Boolean(noun && noun.index > verb.index);
-  });
-  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
-  // 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);
-  // A bounded, recognizable reporting QUESTION about what changed ("Tham số/cấu hình
-  // nào đã thay đổi, nếu có." / "which configuration has changed, if any") is a
-  // status report even without a lookup verb — but ONLY when no actionable clause
-  // actually orders a mutation: a mixed request ("Add a dark-mode button; report
-  // which configuration changed") keeps its implementation contract and evidence.
-  // The two lookbehinds keep a question's noun ("what change was made") and the
-  // Vietnamese past-tense verb "thay đổi" from counting as mutation orders.
-  const ACTIONABLE_MUTATION_ORDER = /(?<!\b(?:what|which|how|nao|gi)\s)(?<!thay )\b(?:implement|fix(?:es)?|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/;
-  const configReportQuestion = !actionable.some((clause) => ACTIONABLE_MUTATION_ORDER.test(clause))
-    && actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh|tham so)\b/.test(clause)
-      && CONFIG_CHANGE_REPORT_CLAUSE.test(clause));
-  const statusReport = (configReportQuestion || (!mutationWord
-      && /\b(?:check|status|report|show|summari[sz]e|result|results|kiem tra|bao cao|trang thai|ket qua|da len chua)\b/.test(text)))
-    && !operation && !config;
-  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text) || statusReport)
-    && !sourceOrder && !codeChangeVerb && !operation && !config;
-  const taskKind = operation ? (sourceOrder || (nativeDomain !== 'scheduled-job' && codeChangeVerb) ? 'MIXED' : 'OPERATIONAL')
-    : config ? 'CONFIGURATION' : documentation ? 'DOCUMENTATION_OUTPUT' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
-  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
-  return { taskKind, ...(releasePolicy ? { releasePolicy } : {}), ...(documentation ? { reportArtifact } : {}), ...(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' } } : {}) };
-}
-
-function applyTaskSemantics(contract, semantic) {
-  const evidence = contract?.completionEvidence || [];
-  const operationOnly = semantic.taskKind === 'OPERATIONAL'
-    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
-  return { ...(contract || {}), ...semantic,
-    completionEvidence: semantic.taskKind === 'DOCUMENTATION_OUTPUT' ? ['report-artifact'] : operationOnly ? ['operation-verification']
-      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
-        : semantic.taskKind === 'READ_ONLY' && semantic.statusReport ? []
-        : semantic.taskKind === 'READ_ONLY' ? (semantic.verificationOnly || (evidence.length === 1 && evidence[0] === 'verification-evidence') ? ['verification-evidence'] : ['impact-evidence']) : evidence };
-}
 
   function buildRouteSummary({
     activeSkills = [],
@@ -2139,7 +2454,6 @@ function applyTaskSemantics(contract, semantic) {
       nextActionType: nextAction?.type || null,
       nextActionCommand,
       helperHint,
-      // FR-004 additive field — present only for advisor/reference/replan prompts.
       ...(advisorIntent ? { advisorIntent } : {}),
       line: line || 'task=unknown',
     };
@@ -2236,16 +2550,9 @@ function applyTaskSemantics(contract, semantic) {
     const questionSignal = raw.includes('?')
       || /\b(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
       || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu|nghĩa là|được không|không\b)/.test(raw);
-    // '?' or a leading/Vietnamese interrogative — required to overrule error wording.
     const strongQuestion = raw.includes('?')
       || /^(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
       || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu)/.test(raw);
-    // C85-019: consult-shaped questions overrule subject-matter signal scores.
-    // "should I fix X?", "X chưa nhỉ?", "có nên/có cần sửa không?" mention
-    // mutation vocabulary as SUBJECT — the ask is a decision/answer, not an
-    // order. Tight on purpose: modal-subject inversion restricted to
-    // should/shall (decision asks) — "how do I fix…?" and "bạn có thể sửa…
-    // giúp tôi không?" are work-shaped questions, not consults.
     const folded = raw.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/\u0111/g, 'd');
     const politeAsk = /\b(?:giup|giuong|ho|dum)\b[^\n?,;]{0,60}\b(?:khong|không)\s*[?!.]?\s*$/.test(folded)
       || /\bcho\b[^\n?,;]{0,60}\b(?:khong|không)\s*[?!.]?\s*$/.test(folded);
@@ -2254,8 +2561,6 @@ function applyTaskSemantics(contract, semantic) {
       || /\b(?:chua|duoc khong|dung khong|khong nhi|nhi|roi)\s*[.!?]*\s*$/.test(folded)
       || (!politeAsk && /\b(?:khong|không)\s*[?.!]?\s*$/.test(folded))
       || /\bchi\s+(?:hoi|tu\s+van|giai\s+thich|xem)\b/.test(folded);
-      // P1: a consult-shaped clause ("Should I also bump…?", a Vietnamese tail) must never demote a prompt that
-      // still carries a real imperative order — otherwise the order loses its completion contract.
       if (consultShape && hasMutationOrder({ promptText, commandText })) return false;
     if (scores) {
       if (!consultShape && (
@@ -2272,26 +2577,16 @@ function applyTaskSemantics(contract, semantic) {
         return false;
       }
     }
-    // C85-019: consult-shape also overrides the vocabulary vetoes — the
-    // mutation/debug/lỗi words are the question's SUBJECT, not the ask.
     const implementWords = /(?<![A-Za-z0-9_])(implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|sửa|thêm|tạo|xóa|đổi|thay thế|cập nhật|viết|build|chạy|cài)(?![A-Za-z0-9_])/.test(raw);
     if (implementWords && !consultShape) return false;
     const investigationWords = /\b(why|debug|triage|root cause|investigate|tại sao)\b/.test(raw);
     if (investigationWords && !consultShape) return false;
-    // \b never matches around 'lỗi' (diacritics are not \w), so test it as a plain
-    // substring: an error report is informational only when phrased as a question.
     if (raw.includes('lỗi') && !strongQuestion && !consultShape) return false;
     const reviewWords = /\b(review|audit|verify)\b/.test(raw);
     if (reviewWords && !consultShape) return false;
-    // C85-019: consult shape is itself a question signal (Vietnamese tails like
-    // "chưa"/"rồi" never match the Latin interrogative regex above).
     return questionSignal || consultShape;
   }
 
-  // Greeting fast-path (parity with route-task.mjs isPureGreetingPrompt): a
-  // bare "hi" / "xin chào" / "thanks" (≤6 tokens, no command, no target) is an
-  // informational turn — no mutating lane, no task debt. Any non-greeting
-  // word ("hi, fix the login bug") disqualifies the prompt.
   function isPureGreetingPrompt({ promptText = '', commandText = '', targetFile = null } = {}) {
     const raw = String(promptText ?? '').trim();
     if (!raw || String(commandText ?? '').trim() || targetFile) return false;
@@ -2320,21 +2615,6 @@ function applyTaskSemantics(contract, semantic) {
     return coreHit;
   }
 
-  // TASK-C85-019: an explicit no-change/advisory assertion overrides the signal
-  // scores. A report or advisory question carrying fix vocabulary as SUBJECT
-  // MATTER ("không tạo thay đổi", "giữ nguyên mã", "do not change anything",
-  // "chỉ tư vấn") still fires implementSignal/smallFixSignal/failureSignal,
-  // which used to route the turn mutating so the completion gate demanded an
-  // Edit the user explicitly declined. The override fires only when an
-  // assertion phrase is present AND no unambiguous implement order survives
-  // outside the negated/advisory/quoted/report clauses: "sửa file X nhưng giữ
-  // nguyên Y" keeps its mutation lane because 'sửa file X' is outside the
-  // keep-clause, while "hook cần được cấu hình để chỉ yêu cầu bằng chứng sửa
-  // file" is a description of the hook's behavior, not an order. Folded
-  // (diacritic-free) text is matched so both Vietnamese spellings work.
-  // Interrogative-deontic forms ("should I…?", "có cần sửa…?") count as
-  // advisory requests, not orders; a bare "không biết…chưa" uncertainty is NOT
-  // an assertion and stays on the plain question path.
   function hasAdvisoryOnlyAssertion({ promptText = '', commandText = '' } = {}) {
     const folded = `${promptText ?? ''}\n${commandText ?? ''}`
       .toLowerCase()
@@ -2358,13 +2638,6 @@ function applyTaskSemantics(contract, semantic) {
       || /\bdung\s+(?:sua|thay\s+doi|edit|chinh)\b/.test(trimmed)
       || /\bchi\s+(?:tu\s+van|hoi|giai\s+thich|xem|la\s+cau\s+hoi)\b/.test(trimmed)
       || /\bco\s+(?:can|nen)\s+sua\b/.test(trimmed)
-      // C89-008 (user-reported 9-stop loop): a waiting/no-change turn asserts
-      // the answer is advisory — "đang chờ kết quả test QAS, không có gì cần
-      // sửa" — but matches none of the shapes above and is not question-shaped,
-      // so it escaped every informational gate and the stop hook demanded an
-      // Edit the honest turn could never produce. 'không có gì' needs its own
-      // trigger — the generic 'không (cần) sửa' pattern cannot skip the 'có
-      // gì' gap.
       || /\bkhong\s+co\s+gi\s+(?:can|phai|de|dang|con)\s+(?:sua|thay\s+doi|lam|chinh|edit|fix)\b/.test(trimmed)
       || /\bnothing\s+(?:to\s+(?:fix|edit|change|update|modify|do)|needs?\s+(?:fixing|editing|changing|updating))\b/.test(trimmed)
       || /\bdang\s+(?:cho|doi)\b/.test(trimmed)
@@ -2372,55 +2645,27 @@ function applyTaskSemantics(contract, semantic) {
       || /\bchua\s+(?:can|nen|phai)\s+(?:sua|thay\s+doi|lam|chinh|edit|fix)\b/.test(trimmed)
       || /\b(?:cho|doi)\s+(?:ket\s+qua|bao\s+cao|feedback|phe\s+duyet|duyet|phien\s+ban|ci|test|qas|review|build|deploy|approval|xong)\b/.test(trimmed);
     if (!advisoryAssertion) return false;
-    // Strip quoted spans and every clause class that can carry mutation
-    // vocabulary without being an order: the advisory/negated assertions
-    // themselves, conditional or purpose clauses (nếu/để/cho/if), reported
-    // demands of another agent (yêu cầu/ép/bắt/requires/forced), passive
-    // necessity descriptions (cần được cấu hình/must be configured), and the
-    // ledger's own evidence-class names. Whatever mutation verb remains after
-    // the strip is an actual implement order and vetoes the advisory route.
-    // C85-019c: clause strips must stop BEFORE a conjunction-joined imperative
-    // — "giữ nguyên header và sửa lỗi login" keeps 'và sửa lỗi' as a surviving
-    // order; an unbounded [^.,;\n]* swallows it and the order escapes the gate.
-    // TAIL = lazy strip ending before 'và'/'and' (folded va|and) or EOS.
     const MUT_VERBS = 'implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh';
     const TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
-    // C89-008: WAIT_TAIL ends a waiting-clause strip before any coordinating
-    // conjunction ('và/and/nhưng/rồi/then/later/sau đó') followed by anything
-    // up to a mutation verb, or at punctuation/EOS — "đang chờ kết quả nhưng
-    // sửa file này" keeps 'sửa file này' as a surviving order.
     const WAIT_TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and|nhung|roi|then|later|sau\\s+do)\\s+[^.,;\\n]*?\\b(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
     const residue = trimmed
       .replace(/"[^"\n]*"|«[^»\n]*»/g, ' ')
-      // "tạo plan" / "create a plan": the plan is the deliverable, not a mutation order.
       .replace(/\b(?:tao|lap|viet|create|make|write|draft|produce)\s+(?:cho\s+toi\s+)?(?:a\s+|an\s+|the\s+|1\s+|mot\s+)?(?:one\s+)?(?:structured\s+|forensic\s+|short\s+|brief\s+)?(?:plan|ke\s+hoach|phuong\s+an|lo\s+trinh|roadmap|bao\s+cao|report|danh\s+gia|assessment)\b/g, ' ')
       .replace(/\bwrite-evidence\b|\bverification-evidence\b|\bimpact-evidence\b|\broot-cause\b/g, ' ')
-      // P1-A (forensic false block): nouns and investigation questions are not orders. 'write/verification
-      // advisory', 'state change', 'each proposed fix' name things; 'whether X may create Y' asks a question to
-      // answer. A negated ENUMERATION with objects ('do not implement fixes, modify source code, ... or create
-      // commits') negates every item to its sentence end; the older verb-only chain broke at 'fixes'.
       .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
       .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
       .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ')
       .replace(new RegExp(`\\bwhether\\b[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:${MUT_VERBS})(?![A-Za-z0-9_])|[.,;\\n]|$)`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|not|khong(?:\\s+duoc)?|tuyet\\s+doi\\s+khong)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])(?:[^.,;\\n\u2014]*?(?:\\s*,\\s*(?:(?:or|and|nor|hay|hoac|va)\\s+)?|\\s+(?:or|nor|hay|hoac)\\s+)(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh|restart|manipulate|resume|push|merge|publish|touch|alter|reset|rollback|revert|commit|kill|release|tag)(?![A-Za-z0-9_]))*[^.,;\\n\u2014]*?(?=\\s+(?:va|and|then|roi|nhung|but)\\s|[.,;\u2014\\n]|\\s*$)`, 'g'), ' ')
-      // A negated LIST ("do not implement, fix, or refactor"; "khong implement, sua, refactor hay chinh") negates every
-    // verb in the list: the TAIL strip below stops at the first comma, which would leave the later verbs as orders.
     .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|not|khong(?:\\s+duoc)?|tuyet\\s+doi\\s+khong)\\s+(?:${MUT_VERBS})(?![A-Za-z0-9_])(?:\\s*(?:,|,?\\s+(?:or|and|nor|hay|hoac|va))\\s*(?:(?:${MUT_VERBS})(?![A-Za-z0-9_])|(?:${MUT_VERBS})\\s))*[^.,;\\n\u2014]*?(?=\\s+(?:va|and|then|roi|nhung|but)\\s|[.,;\u2014\\n]|\\s*$)`, 'g'), ' ')
       .replace(new RegExp(`\\bgiu\\s+nguyen\\b${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bmuon\\s+giu\\b${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:khong|chua)\\s+(?!chi\\b)${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bdung\\s+${TAIL}`, 'g'), ' ')
-      // C89-008: a waiting clause narrates what the TURN waits on, not what
-      // the request orders — verbs inside it ("chờ sửa xong", "waiting for
-      // the fix") belong to the wait, not to the implement order.
       .replace(new RegExp(`\\bdang\\s+(?:cho|doi)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:waiting|awaiting)\\s+(?:for|on)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:cho|doi)\\s+(?:ket\\s+qua|bao\\s+cao|feedback|phe\\s+duyet|duyet|phien\\s+ban|ci|test|qas|review|build|deploy|approval|xong)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bnothing\\s+(?:to|needs?)\\b${TAIL}`, 'g'), ' ')
-      // 'chưa cần/nên/phải sửa' defers the change — same class as 'không cần
-      // sửa' but 'chưa' is not covered by the 'không' strip above. WAIT_TAIL
-      // bounds it so '…nhưng sửa phần này' keeps the surviving order.
       .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:de|cho)\\s+${TAIL}`, 'g'), ' ')
@@ -2437,77 +2682,49 @@ function applyTaskSemantics(contract, semantic) {
     return !mutationOrder;
   }
 
-  // C85-019: mutation vocabulary ≠ mutation order. The same residue logic the
-  // advisory gate uses — quotes, negated clauses, conditionals (nếu/để/cho/if),
-  // reported demands (yêu cầu/ép/requires), necessity phrases (cần được/must
-  // be), evidence-class names — decides whether ANY surviving verb is an
-  // imperative. Used by hasAdvisoryOnlyAssertion and by the question-shape
-  // gate below (question + no order → consult).
   function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
-    const folded = `${promptText ?? ''}\n${commandText ?? ''}`
+    const folded = `${publicationScope(promptText).text}\n${commandText ?? ''}`
       .toLowerCase()
       .normalize('NFD')
       .replace(/[\u0300-\u036f]/g, '')
       .replace(/\u0111/g, 'd');
     const trimmed = folded.trim();
     if (!trimmed) return false;
-    if (!String(commandText ?? '').trim() && classifyTaskSemantics({ promptText }).verificationOnly === true) return false;
-    // C85-019c: clause strips must stop BEFORE a conjunction-joined imperative
-    // — "giữ nguyên header và sửa lỗi login" keeps 'và sửa lỗi' as a surviving
-    // order; an unbounded [^.,;\n]* swallows it and the order escapes the gate.
-    // TAIL = lazy strip ending before 'và'/'and' (folded va|and) or EOS.
+    if (ordersPublication(promptText)) return true;
+    if (!String(commandText ?? '').trim() && (declaredReadOnly(promptText, classifyTaskSemantics({ promptText }).releasePolicy)
+      || classifyTaskSemantics({ promptText }).verificationOnly === true)) return false;
+    if (/^(?:we\s+need|i\s+want|can)\s+(?:a\s+|an\s+|mot\s+)?[^.;\n]*\b(?:feature|flag|option|tinh nang)\b/.test(trimmed)) return true;
     const MUT_VERBS = 'implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh';
     const TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
-    // C89-008: WAIT_TAIL ends a waiting-clause strip before a coordinating
-    // conjunction ('và/and/nhưng/rồi/then/later/sau đó') followed by anything
-    // up to a mutation verb, or at punctuation/EOS.
     const WAIT_TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and|nhung|roi|then|later|sau\\s+do)\\s+[^.,;\\n]*?\\b(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
-    const residue = trimmed
+    const residue = neutralizeNonOrders(trimmed)
       .replace(/"[^"\n]*"|«[^»\n]*»/g, ' ')
-      // "tạo plan" / "create a plan": the plan is the deliverable, not a mutation order.
       .replace(/\b(?:tao|lap|viet|create|make|write|draft|produce)\s+(?:cho\s+toi\s+)?(?:a\s+|an\s+|the\s+|1\s+|mot\s+)?(?:one\s+)?(?:structured\s+|forensic\s+|short\s+|brief\s+)?(?:plan|ke\s+hoach|phuong\s+an|lo\s+trinh|roadmap|bao\s+cao|report|danh\s+gia|assessment)\b/g, ' ')
-      // Descriptive state, not an order: "đã/vừa [được] + verb" ("hooks vừa được cài đặt") reports
-      // something already done. Only the verb is stripped, so a later imperative still survives.
       .replace(/(?<![a-z0-9_])(?:da|vua)\s+(?:duoc\s+)?(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![a-z0-9_])/g, ' ')
       .replace(/\bwrite-evidence\b|\bverification-evidence\b|\bimpact-evidence\b|\broot-cause\b/g, ' ')
-      // P1-A (forensic false block): nouns and investigation questions are not orders. 'write/verification
-      // advisory', 'state change', 'each proposed fix' name things; 'whether X may create Y' asks a question to
-      // answer. A negated ENUMERATION with objects ('do not implement fixes, modify source code, ... or create
-      // commits') negates every item to its sentence end; the older verb-only chain broke at 'fixes'.
       .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
       .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
       .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ')
       .replace(new RegExp(`\\bwhether\\b[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:${MUT_VERBS})(?![A-Za-z0-9_])|[.,;\\n]|$)`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|not|khong(?:\\s+duoc)?|tuyet\\s+doi\\s+khong)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])(?:[^.,;\\n\u2014]*?(?:\\s*,\\s*(?:(?:or|and|nor|hay|hoac|va)\\s+)?|\\s+(?:or|nor|hay|hoac)\\s+)(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh|restart|manipulate|resume|push|merge|publish|touch|alter|reset|rollback|revert|commit|kill|release|tag)(?![A-Za-z0-9_]))*[^.,;\\n\u2014]*?(?=\\s+(?:va|and|then|roi|nhung|but)\\s|[.,;\u2014\\n]|\\s*$)`, 'g'), ' ')
-      // A negated LIST ("do not implement, fix, or refactor"; "khong implement, sua, refactor hay chinh") negates every
-    // verb in the list: the TAIL strip below stops at the first comma, which would leave the later verbs as orders.
     .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|must\\s+not|never|not|khong(?:\\s+duoc)?|tuyet\\s+doi\\s+khong)\\s+(?:${MUT_VERBS})(?![A-Za-z0-9_])(?:\\s*(?:,|,?\\s+(?:or|and|nor|hay|hoac|va))\\s*(?:(?:${MUT_VERBS})(?![A-Za-z0-9_])|(?:${MUT_VERBS})\\s))*[^.,;\\n\u2014]*?(?=\\s+(?:va|and|then|roi|nhung|but)\\s|[.,;\u2014\\n]|\\s*$)`, 'g'), ' ')
       .replace(new RegExp(`\\bgiu\\s+nguyen\\b${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bmuon\\s+giu\\b${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:khong|chua)\\s+(?!chi\\b)${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bdung\\s+${TAIL}`, 'g'), ' ')
-      // C89-008: a waiting clause narrates what the TURN waits on, not what
-      // the request orders — verbs inside it belong to the wait.
       .replace(new RegExp(`\\bdang\\s+(?:cho|doi)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:waiting|awaiting)\\s+(?:for|on)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:cho|doi)\\s+(?:ket\\s+qua|bao\\s+cao|feedback|phe\\s+duyet|duyet|phien\\s+ban|ci|test|qas|review|build|deploy|approval|xong)\\b${WAIT_TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\bnothing\\s+(?:to|needs?)\\b${TAIL}`, 'g'), ' ')
-      // 'chưa cần/nên/phải sửa' defers the change — WAIT_TAIL bounds it so a
-      // '…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.
       .replace(new RegExp(`\\bkhi\\s+(?:toi|ta|ban|no|anh|chi|he|she|we)\\s+[^.,;\\n?]*?(?=\\s+(?:va|and)\\b|\\s*$)`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:de|cho)\\s+${TAIL}`, 'g'), ' ')
       .replace(new RegExp(`\\b(?:yeu\\s+cau|doi\\s+hoi|ep\\s+phai|bat\\s+buoc|bat\\s+phai)\\b${TAIL}`, 'g'), ' ')
@@ -2519,19 +2736,16 @@ function applyTaskSemantics(contract, semantic) {
       .replace(/\b(?:just|only|simply)\s+(?:advis\w*|asking?|a\s+question|answering?|explaining?|consulting|reporting)\b[^.,;\n]*/g, ' ')
       .replace(/\badvisory\s+only\b[^.,;\n]*/g, ' ')
       .replace(new RegExp(`\\bkeep\\s+[^\\n.,;]{0,60}\\b(?:unchanged|as\\s+is|the\\s+same|intact)\\b${TAIL}`, 'g'), ' ')
-      // C85-019b: question-tagged mutation verbs are asks, not orders.
       // English: "<modal> I/we <verb>" (should I fix). Vietnamese: S-V-order
       // status questions — "<verb> … (chưa|được không|rồi|nhỉ)?" means "has
-      // it been done", never "do it". EXCLUDED: "… giúp/cho/hộ/dùm tôi
-      // không?" — the 'không' is a polite request marker, not a status tag;
-      // also EXCLUDED are wh-led modals ("which files should I update") —
-      // a selection ask is a plan, not a yes/no consult. Strips run LAST
-      // so a real imperative mid-sentence ("sửa file X cho tôi") survives.
       .replace(/\b(?<!\b(?:which|what|how)\s[^.,;?]{0,30})(?:should|shall)\s+(?:i|we)\s+[^\n?]*[?]?/g, ' ')
       .replace(/[^\n.,;?]{0,80}\b(?:chua|duoc khong|dung khong|khong nhi|nhi|roi|a)\s*[?]?\s*$/g, ' ')
       .replace(/^(?!.*\b(?:giup|giuong|cho|ho|dum)\b)[^\n.,;?]{0,80}\b(?:khong|không)\s*[?]?\s*$/g, ' ')
       .replace(/\b(?:co|có)\s+(?:nen|can|phai)\s+[^\n?]*[?]?/g, ' ');
-    return /(?<![A-Za-z0-9_])(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![A-Za-z0-9_])/.test(residue);
+    return /(?<![A-Za-z0-9_])(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![A-Za-z0-9_])/.test(residue)
+      // The canonical engine is the authority on additive/imperative change orders (bo sung, bat buoc them ...)
+      // that the residue stripping above treats as obligation prose; the copies must not disagree.
+      || ordersAdditiveChange(promptText);
   }
 
   // <advisor-intent:begin>
@@ -2666,11 +2880,6 @@ function applyTaskSemantics(contract, semantic) {
       return 'informational';
     }
 
-    // TASK-C85-019: an explicit no-change/advisory assertion beats every signal
-    // score — the prompt mentions mutation vocabulary as subject matter, not as
-    // an order. Checked before the review/delivery/consultation gates so an
-    // advisory turn never mints write or verification debt; a surviving
-    // imperative outside the negated clause still routes mutating.
     if (hasAdvisoryOnlyAssertion({ promptText, commandText })) {
       return 'informational';
     }
@@ -2693,18 +2902,7 @@ function applyTaskSemantics(contract, semantic) {
     const questionShapedPrompt = /\?\s*$/.test(trimmedPromptText)
       || leadingInterrogative
       || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText)
-      // C85-019: Vietnamese status/consult tails without a '?' — "… chưa",
-      // "… chưa nhỉ", "… không nhỉ", "… đúng không". A question about a defect
-      // must not mint the bug-fix floor's write/repro debt.
       || /\b(?:chua|duoc khong|dung khong|khong nhi|khong|nhi)\s*[.!?]*\s*$/.test(foldedPromptText);
-    // Implement verbs (Vietnamese included — the English-only scores above cannot see
-    // them) mark an action order even when phrased as a question ("ban sua giup toi…?" is
-    // an edit order, not a consultation). A leading interrogative overrides them:
-    // "Lam sao ma do duoc khi toi cai…?" asks HOW something is done, it does not order
-    // the action performed.
-    // C85-019: question shape + no surviving imperative = consult. The
-    // pre-C85-019 all-zero-scores clause consulted only when NOTHING in the
-    // prompt resembled work — impossible for a question about code. Replacing
     // it with hasMutationOrder keeps "sửa file cho tôi?" mutating while
     // "lỗi này chưa nhỉ" / "should I fix the hook?" consult. A targetFile
     // still vetoes.
@@ -3952,10 +4150,17 @@ function applyTaskSemantics(contract, semantic) {
       && !storedContract.statusReport && previous.routingContext?.lastExplicitUserPromptText) {
       try {
         const fresh = classifyTaskSemantics({ promptText: previous.routingContext.lastExplicitUserPromptText, targetFile: persisted.routingContext?.targetFile });
-        // Compare every classifier-owned obligation field, not just the kind: a stale operationGoal /
-        // configurationScope / releasePolicy under an unchanged kind is the same false-obligation bug.
-        const sig = (c) => JSON.stringify([c?.taskKind, c?.operationGoal ?? null, c?.configurationScope ?? null, c?.releasePolicy?.kind ?? null, c?.reportArtifact ?? null]);
-        if (fresh?.taskKind && sig(fresh) !== sig(storedContract)) semanticFromPrompt = fresh;
+        // Always compare the complete semantic contract, including evidence and flags.
+        // Partial signatures hid contradictions under an unchanged task kind.
+        if (fresh?.taskKind) {
+          const identity = semanticContractIdentity({ promptText: previous.routingContext.lastExplicitUserPromptText,
+            targetFile: persisted.routingContext?.targetFile || '', taskInstanceId });
+          const comparison = compareSemanticContracts({ stored: storedContract,
+            fresh: applyTaskSemantics(buildExecutionContract(persisted.routeSummary?.executionMode || 'local-build'), fresh),
+            previousIdentity: previous.semanticIdentity, identity });
+          if (comparison.status === 'invariant-violation') persisted.semanticDiagnostic = comparison;
+          else if (comparison.status !== 'equal') semanticFromPrompt = fresh;
+        }
       } catch {}
     }
     const semantic = semanticFromPrompt
@@ -3963,15 +4168,26 @@ function applyTaskSemantics(contract, 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) {
+    // Only an authoritative request (or an owned continuation) creates debt.
+    // Answer turns suspend it regardless of the classifier's fallback kind;
+    // a tool-only event without an owned contract cannot synthesize a new task.
+    const turnPrompt = extractPrompt(payload);
+    const answerQuestion = /\?\s*$/.test(turnPrompt)
+      && !/\b(?:review|audit|investigate|forensic)\b/i.test(turnPrompt);
+    const informationalTurn = !continuingTask && !semantic.statusReport
+      && (semantic.taskKind === 'CODE_IMPLEMENTATION' || answerQuestion)
+      && (isInformationalPrompt({ promptText: turnPrompt })
+        || isPureGreetingPrompt({ promptText: turnPrompt }));
+    const unownedToolTurn = !extractPrompt(payload) && payload.tool_name && !storedContract;
+    if (informationalTurn || unownedToolTurn) {
       // 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() }
+            routeSummary: previous.routeSummary, routingContext: previous.routingContext,
+            semanticIdentity: previous.semanticIdentity, semanticDiagnostic: previous.semanticDiagnostic,
+            contractOrigin: previous.contractOrigin, ts: Date.now() }
         : previous.suspendedContract;
       if (parked) persisted.suspendedContract = parked;
       delete persisted.routeSummary;
@@ -3982,7 +4198,9 @@ function applyTaskSemantics(contract, semantic) {
       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() }
+            routeSummary: previous.routeSummary, routingContext: previous.routingContext,
+            semanticIdentity: previous.semanticIdentity, semanticDiagnostic: previous.semanticDiagnostic,
+            contractOrigin: previous.contractOrigin, ts: Date.now() }
         : previous.suspendedContract;
       if (parked) persisted.suspendedContract = parked;
       persisted.routeSummary ||= { executionMode: 'local-build' };
@@ -3991,7 +4209,7 @@ function applyTaskSemantics(contract, semantic) {
       if (persisted.contractOrigin !== 'carried-system') persisted.contractOrigin = 'classified';
       delete persisted.routeSummary.completionState;
       delete persisted.routeSummary.continuationState;
-    } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary) {
+    } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary || persisted.routingContext?.mutationOrder === true) {
       persisted.routeSummary ||= { executionMode: 'local-build' };
       if ((semanticFromPrompt || !continuingTask) && persisted.routeSummary.executionContract) {
         // A NEW task never inherits the previous task's classifier-owned obligations either (e.g. a stale
@@ -4000,8 +4218,8 @@ function applyTaskSemantics(contract, semantic) {
         const kept = { ...persisted.routeSummary.executionContract };
         // statusReport / verificationOnly are only stripped on re-derivation: for a NEW task they drive the
         // carried-status rebuild below, so they must survive to be recognised there.
-        const staleKeys = semanticFromPrompt ? ['operationGoal', 'configurationScope', 'releasePolicy', 'reportArtifact', 'verificationOnly', 'statusReport']
-          : ['operationGoal', 'configurationScope', 'releasePolicy', 'reportArtifact'];
+        const staleKeys = semanticFromPrompt ? ['publication', 'operationGoal', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact', 'verificationOnly', 'statusReport']
+          : ['publication', 'operationGoal', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact'];
         for (const key of staleKeys) delete kept[key];
         // MIXED/OPERATIONAL evidence tags belong to the previous task's classification: a new task starts from
         // the mode's base evidence so it is not asked for operation proof its own prompt never ordered.
@@ -4053,6 +4271,17 @@ function applyTaskSemantics(contract, semantic) {
       && (!persisted.routeSummary || persisted.routeSummary.executionContract?.statusReport)) {
       persisted.suspendedContract = previous.suspendedContract;
     }
+    if (persisted.semanticDiagnostic?.status === 'invariant-violation' && previous.routeSummary?.executionContract) {
+      persisted.routeSummary.executionContract = previous.routeSummary.executionContract;
+    }
+    if (persisted.contractOrigin === 'classified' && persisted.routingContext?.lastExplicitUserPromptText) {
+      const intentInput = { promptText: persisted.routingContext.lastExplicitUserPromptText,
+        targetFile: persisted.routingContext.targetFile || '', taskInstanceId: persisted.taskInstanceId, sessionId };
+      persisted.semanticIdentity = semanticContractIdentity(intentInput);
+      const analysis = analyzeTaskIntent(intentInput);
+      persisted.semanticProvenance = { engineVersion: analysis.engineVersion, actions: analysis.actions,
+        spans: analysis.spans.map(({ raw, ...span }) => span) };
+    }
     text = JSON.stringify(persisted);
     await writeJsonFileAtomic(statePath, text);
     if (!sessionId) return persisted;
@@ -4088,7 +4317,9 @@ function applyTaskSemantics(contract, semantic) {
     && 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 };
+      requestKey: parkedContract.requestKey, routingContext: parkedContract.routingContext || previous.routingContext,
+      semanticIdentity: parkedContract.semanticIdentity, semanticDiagnostic: parkedContract.semanticDiagnostic,
+      contractOrigin: parkedContract.contractOrigin };
     delete previous.suspendedContract;
   }
   // A turn the SYSTEM injected (a harness /loop wakeup, or the post-compaction "session is being
@@ -4348,8 +4579,6 @@ function applyTaskSemantics(contract, semantic) {
   const keptActive = active.filter((entry) => shouldKeepRouteEntryForIntent(entry, intentMode));
   active.length = 0;
   active.push(...keptActive);
-  // FR-004: a classified advisor/reference/replan hand-off always loads
-  // advisor-plan, even when no catalog signal fired. It takes the FIRST of the
   // two active-skill slots; the best-scoring other route fills the second.
   const advisorIntent = classifyAdvisorRequest({ promptText, commandText });
   const advisorCatalogEntry = advisorIntent
@@ -4764,7 +4993,6 @@ function applyTaskSemantics(contract, semantic) {
     });
     mergeResolverFields(routeSummary, finalSharedFields);
     inheritTaskPlaybook(routeSummary, previous, taskInstanceId);
-    // BL-019 (SPEC FR-001): fold the persisted measured map into the route —
     // identical semantics to route-task.mjs finalizeTaskRoute / taskRouting.js
     // deriveTaskRoute: measuredTier emitted additively; modelTier follows the
     // map only when tier-map.json says 'promote'. Advisory — every failure