@ngockhoale/ukit 3.4.52 → 3.4.54

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to UKit are documented here.
 
+## 3.4.54 - 2026-10-22
+
+**Completion Gate: a stated prohibition is not an operation order (field false-block).**
+- Fix: `classifyTaskSemantics` (src + shipped `route-resolver.mjs` mirror) treated "Production deploy/restart vẫn bị cấm", "production deploy vẫn bị chặn", "forbidden deploy/publish" and a bare list item "Production restart." as actionable runtime operations, so an audit/report prompt became MIXED + service-runtime and the Stop gate demanded `operation-verification` for a restart nobody ordered.
+- New guard `operationNotOrdered` applies to the git/runtime operation checks only: a prohibition attached to the operation, or a bare production-operation noun item, orders nothing. Lift/past markers ("was prohibited, owner now allows", "even though it is not allowed", "khong bi chan") keep the clause an order. Real orders (restart + verify, deploy to production, fix + restart) are unchanged.
+- Regression: `tests/hooks/prohibitionNotOrder.test.js` (78 cases across src + installed copies) with the real field prompt fixture. Ledger, gates and release logic untouched.
+- Verified offline on macOS/Node 22; OMP/Claude Code coverage is classifier replay, not live host.
+
+## 3.4.53 - 2026-10-22
+
+**Stop-level closure of the UNPROVEN verdict (follow-up to 3.4.52).**
+- `recoveryInstruction`: a non-current `unproven` verdict no longer yields "verdict is stale, re-run at current head"; it names the real gap (masked pipe, exit status unproven) and never "fix the failure".
+- `stop-coordinator`: the `verify:pass` predicate and `goalVerificationVerdict` treat `unproven` as unmet but report "unproven (exit status not proven)", not a verified failure; `unproven` never counts as a pass.
+- New Stop-level regressions (`tests/hooks/executionLedgerStopLifecycle.test.js`, GC-03e): UNPROVEN neither failure nor PASS; exhausted retry budget ends visibly without a recovery loop or write demand; same-task same-command PASS clears its own blocker, a different command / UNPROVEN rerun / another task does not; a superseded failure stops producing recovery text.
+- Note: `tests/handoff/**` is excluded from `vitest`; run `tests/handoff/goalCompletion.test.js` with `node --test` (vitest exits 1 with "No test files found").
+- Verified offline on macOS/Node 22; no live host proof.
+
 ## 3.4.52 - 2026-10-22
 
 **Verification-loop ledger integrity (post-3.4.51 follow-up).**

package/manifests/documentation.yaml

@@ -82,6 +82,17 @@ entries:
     validation: [manual, test:tests/hooks/executionLedger.test.js, test:tests/hooks/verificationExitProof.test.js]
     archive_policy: replace-with-snapshot
     notes: evidence-based long-run field audit; current reproductions are distinct from incident attribution
+  - id: root-62h-field-regression-crosscheck
+    path: UKIT_62H_FIELD_REGRESSION_CROSSCHECK.md
+    class: canonical
+    audience: [owner, maintainer]
+    owner: runtime
+    source_of_truth: UKIT_62H_FIELD_REGRESSION_CROSSCHECK.md
+    merge_strategy: none
+    load_policy: on-demand
+    validation: [manual, test:tests/hooks/prohibitionNotOrder.test.js]
+    archive_policy: replace-with-snapshot
+    notes: BAGuide 62h field cross-check; observed/reproduced/hypothesis/unknown labelled, gate false-block root cause
   - id: registry-self
     path: manifests/documentation.yaml
     class: canonical

package/package.json

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

package/src/core/executionContracts.js

@@ -265,6 +265,22 @@ export function isVerificationOnlyRequest(promptText) {
     && !clauses.some((clause) => CHANGE_LEAD.test(clause));
 }
 
+// "Deploy and restart are banned", "Forbidden: deploy", "deploy: banned" name operations to prohibit them. The clause split on
+// "and"/commas would separate the ban from the first operation, so a banned operation list is removed before splitting.
+function neutralizeBannedLists(text) {
+  const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin)';
+  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({ 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();
@@ -272,7 +288,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   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 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|dung)\b/.test(clause)
     && !/^\s*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
@@ -293,11 +309,40 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // 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));
+  // A clause that STATES an operation is prohibited ("production deploy vẫn bị cấm", "forbidden deploy") or merely lists a
+  // production operation as a bare noun item ("* Production restart.") names it; it does not order it.
+  const operationNotOrdered = (clause) => {
+    const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin)';
+    const BAN = '(?:bi\\s+(?:cam|chan)|forbidden|prohibited|banned|not\\s+allowed|not\\s+permitted|disallowed)';
+    // A lift or past marker ("was prohibited, owner now allows", "even though it is not allowed", "khong bi chan")
+    // means the prohibition is history or lifted: the clause still orders the operation.
+    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;
+    // Evaluated per operation occurrence: the clause orders nothing only when EVERY operation in it is prohibited.
+    // The ban must attach to its own operation: no parenthesis, dash, colon, conjunction, relative pronoun or second operation in between.
+    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)`);
+    // "deploy/restart is forbidden", "deploy and restart are banned": operations joined as a list share one ban.
+    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) && /\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)
+  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);

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

@@ -1162,6 +1162,22 @@ export function isVerificationOnlyRequest(promptText) {
     && !clauses.some((clause) => CHANGE_LEAD.test(clause));
 }
 
+// "Deploy and restart are banned", "Forbidden: deploy", "deploy: banned" name operations to prohibit them. The clause split on
+// "and"/commas would separate the ban from the first operation, so a banned operation list is removed before splitting.
+function neutralizeBannedLists(text) {
+  const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin)';
+  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({ 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();
@@ -1169,7 +1185,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   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 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|dung)\b/.test(clause)
     && !/^\s*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
@@ -1190,11 +1206,40 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // 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));
+  // A clause that STATES an operation is prohibited ("production deploy vẫn bị cấm", "forbidden deploy") or merely lists a
+  // production operation as a bare noun item ("* Production restart.") names it; it does not order it.
+  const operationNotOrdered = (clause) => {
+    const OP = '(?:restart|redeploy|deploy(?:ment)?|trien khai|khoi dong lai|git\\s+push|push\\s+(?:to\\s+)?origin)';
+    const BAN = '(?:bi\\s+(?:cam|chan)|forbidden|prohibited|banned|not\\s+allowed|not\\s+permitted|disallowed)';
+    // A lift or past marker ("was prohibited, owner now allows", "even though it is not allowed", "khong bi chan")
+    // means the prohibition is history or lifted: the clause still orders the operation.
+    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;
+    // Evaluated per operation occurrence: the clause orders nothing only when EVERY operation in it is prohibited.
+    // The ban must attach to its own operation: no parenthesis, dash, colon, conjunction, relative pronoun or second operation in between.
+    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)`);
+    // "deploy/restart is forbidden", "deploy and restart are banned": operations joined as a list share one ban.
+    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) && /\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)
+  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);

package/template_project/.claude/ukit/runtime/execution-ledger.mjs

@@ -3483,7 +3483,9 @@ function recoveryInstruction(missingEvidence, ledger = {}, routeSummary = {}, {
     if (!instruction && ledger.verdict && typeof ledger.verdict === 'object') {
       if (ledger.verdict.kind === 'check-only') {
         instruction = 'check-only does not satisfy this lane; verify on the real surface (run the feature / inspect the artifact).';
-      } else {
+      } else if (ledger.verdict.kind !== 'unproven') {
+        // An UNPROVEN verdict never satisfied the gate, so its currency is irrelevant: the
+        // gap is the missing exit status (named below), not a stale head.
         const currency = verdictCurrent(ledger.verdict, { cwd });
         if (currency.current !== true) {
           const sha = ledger.verdict.headSha ? String(ledger.verdict.headSha).slice(0, 12) : 'unknown';

package/template_project/.claude/ukit/runtime/stop-coordinator.mjs

@@ -1065,9 +1065,14 @@ async function evalVerifyPass(projectRoot) {
   for (let i = receipts.length - 1; i >= 0; i -= 1) {
     const r = receipts[i];
     if (!r || typeof r !== 'object' || r.kind !== 'verification') continue;
-    if (r.success === true && r.verdict?.kind !== 'failed') {
+    if (r.success === true && r.verdict?.kind !== 'failed' && r.verdict?.kind !== 'unproven') {
       return { pass: true, detail: 'last verification passed' };
     }
+    // A masked-pipe run (exit status unproven) is not a verified failure: same fail-closed
+    // result, but the detail must say what is actually missing.
+    if (r.exitStatusUnproven === true || r.verdict?.kind === 'unproven') {
+      return { pass: false, detail: 'last verification unproven (exit status not proven)' };
+    }
     return { pass: false, detail: 'last verification failed' };
   }
   return { pass: false, detail: 'no verification receipt recorded' };
@@ -1136,6 +1141,7 @@ function goalVerificationVerdict(ledger) {
   const verdict = typeof ledger.verdict === 'string' ? ledger.verdict.trim().toLowerCase() : null;
   if (verdict === 'pass' || verdict === 'passed' || verdict === 'verified') return { pass: true, detail: 'verification verdict: pass' };
   if (verdict === 'fail' || verdict === 'failed') return { pass: false, detail: 'verification verdict: fail' };
+  if (verdict === 'unproven') return { pass: false, detail: 'verification verdict: unproven (exit status not proven)' };
   if (ledger.verified === true) return { pass: true, detail: 'verification: verified' };
   if (ledger.verified === false) return { pass: false, detail: 'verification: not verified' };
   if (typeof ledger.verify === 'string' && ledger.verify.trim().toLowerCase() === 'pass') return { pass: true, detail: 'verify: pass' };