@ngockhoale/ukit 3.4.68 → 3.4.70

package/template_project/.claude/ukit/index/publication-intent.mjs

@@ -0,0 +1,528 @@
+// Canonical task semantics; intent never grants authorization or proves completion.
+import crypto from 'node:crypto';
+export const SEMANTIC_ENGINE_VERSION = 'round4-semantic-1:1dcaa0253e7bc7f4356b02fe5de33b1edda6f0e00d9f2022d9c8cdbe907003a2';
+
+export 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(),
+]);
+export 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();
+
+export 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));
+}
+
+export 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 };
+}
+
+export 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/;
+export function isVerificationOnlyRequest(promptText) {
+  const plain = String(promptText ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  const clauses = neutralizeNonOrders(plain).split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b|\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 : ' ';
+  });
+}
+
+export 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).
+export 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' } } : {}) };
+}
+
+export 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 };
+}