@ngockhoale/ukit 3.4.57 → 3.4.59

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to UKit are documented here.
 
+## 3.4.59 - 2026-10-22
+
+**Completion Gate: a host-backgrounded verification can now complete through a supported, provenance-bound result capture.**
+- Gap: 3.4.57 made a background launch acknowledgement unproven, but nothing could later turn it into evidence, so the only route was re-running a long suite in the foreground. Claude Code delivers the completion as a task-notification the hooks never see; the host does write the runner's output to `.../tasks/<id>.output` ending in `[exited with code N]`.
+- Fix: when the agent reads that file back, the ledger records a verification receipt bound to the launch receipt by `backgroundTaskId` (same task ledger, so another task/session finds no launch), exit status from the host footer, judged against the LAUNCH tree fingerprint. Rejected: no footer (still running / "passed" text only), no matching launch, duplicate completion, output file older than the launch. Exit 1 yields a failed verdict.
+- Regression: `tests/hooks/backgroundCompletionLifecycle.test.js` (success, failure, partial, duplicate, other task, other session, late, stale file, unrelated file, Stop-gate outcomes). Also `tests/orchestration/schedulingHarness.test.js`: a deterministic offline scheduling-logic model (not a throughput benchmark).
+- Limit: replay of the host file format observed on Claude Code; omp/Codex background shapes are not covered, and no hook receives the notification itself.
+
+## 3.4.58 - 2026-10-22
+
+**Completion Gate: plain publish orders create the registry obligation, new tasks do not inherit the previous task's evidence, and a Vietnamese status line about a config is not a config order.**
+- Bug: "Please/Now npm publish the package", "Đưa package lên npm" and "Phát hành bản này lên npm" were not read as publish orders, so code + tests PASS completed the gate with nothing on the registry. `promptOrdersNpmPublish` now accepts polite/sequencing prefixes and the Vietnamese publish verbs; negations, `--dry-run` and prohibitions still create no debt.
+- Bug: a new task inherited the previous task's classifier-owned contract fields and MIXED evidence (a stale `git-integrity push` goal and `operation-verification` under "npm publish the package"), so a correct publish run stayed blocked on an unordered push. `skill-router.sh` now resets them when a new task starts.
+- Bug: "OMP version/config đã load lúc bắt đầu vẫn unknown" classified CONFIGURATION/external (`bat` in "bắt đầu", `tat` in "tất cả" read as toggle verbs), demanding operation proof for a status report. `bat`/`tat` no longer match those phrases; real "Bật/Tắt config" orders stay CONFIGURATION (3 classifier copies + mirrors).
+- Regression: `tests/hooks/releaseCompletionEvidence.test.js` (resolver → contract → gate), `tests/hooks/configPreferenceNotOrder.test.js` + real-prompt fixture.
+- Limit: the resolver still emits no release-specific contract field; the obligation is enforced gate-side from the prompt. Verified offline on macOS/Node 22; replay, not a live host.
+
 ## 3.4.57 - 2026-10-22
 
 **Completion Gate: background launch acknowledgements are not verification evidence; stale-contract reconciliation covers all obligation fields and the Stop boundary.**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.57",
+  "version": "3.4.59",
   "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

@@ -367,7 +367,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // 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|bat|tat|chinh)\b/;
+  const CONFIG_MUTATION_VERB = /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi|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/;

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

@@ -1982,7 +1982,7 @@ function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
   // 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|bat|tat|chinh)\b/;
+  const CONFIG_MUTATION_VERB = /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi|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/;
@@ -3971,11 +3971,24 @@ function applyTaskSemantics(contract, semantic) {
       delete persisted.routeSummary.continuationState;
     } else if (semantic.taskKind !== 'CODE_IMPLEMENTATION' || persisted.routeSummary) {
       persisted.routeSummary ||= { executionMode: 'local-build' };
-      if (semanticFromPrompt && persisted.routeSummary.executionContract) {
-        // Re-derivation replaces the classifier-owned obligation fields wholesale: applyTaskSemantics
+      if ((semanticFromPrompt || !continuingTask) && persisted.routeSummary.executionContract) {
+        // A NEW task never inherits the previous task's classifier-owned obligations either (e.g. a stale
+        // git-integrity push goal under "npm publish the package"). Re-derivation replaces them wholesale: applyTaskSemantics
         // spreads the old contract first, so a stale operationGoal / releasePolicy would survive.
         const kept = { ...persisted.routeSummary.executionContract };
-        for (const key of ['operationGoal', 'configurationScope', 'releasePolicy', 'reportArtifact', 'verificationOnly', 'statusReport']) delete kept[key];
+        // 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'];
+        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.
+        if ((!continuingTask || semanticFromPrompt) && semantic.taskKind !== 'MIXED' && semantic.taskKind !== 'OPERATIONAL'
+          && Array.isArray(kept.completionEvidence) && kept.completionEvidence.includes('operation-verification')) {
+          const baseMode = persisted.routeSummary.executionMode === 'informational' ? 'local-build' : persisted.routeSummary.executionMode;
+          const base = buildExecutionContract(baseMode);
+          if (Array.isArray(base?.completionEvidence)) kept.completionEvidence = base.completionEvidence;
+        }
         persisted.routeSummary.executionContract = kept;
       }
       // A carried status-report contract must not leak its empty evidence / flag onto a

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

@@ -1264,7 +1264,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // 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|bat|tat|chinh)\b/;
+  const CONFIG_MUTATION_VERB = /\b(?:set|change|toggle|enable|disable|switch|turn|configure|modify|update|edit|doi|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/;

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

@@ -786,6 +786,56 @@ function isBackgroundLaunchAck(response) {
     && /^\s*Command running in background with ID: \S+/.test(response);
 }
 
+// Id of the host background task a launch acknowledgement names (structured field first).
+function backgroundTaskIdOf(response) {
+  if (response && typeof response === 'object' && !Array.isArray(response)) {
+    if (typeof response.backgroundTaskId === 'string' && response.backgroundTaskId) return response.backgroundTaskId;
+    return backgroundTaskIdOf(response.stdout ?? response.output ?? response.content);
+  }
+  const m = typeof response === 'string' ? /^\s*Command running in background with ID: ([A-Za-z0-9_-]+)/.exec(response) : null;
+  return m ? m[1] : null;
+}
+
+function flattenText(value, depth = 0) {
+  if (typeof value === 'string') return value;
+  if (!value || typeof value !== 'object' || depth > 4) return '';
+  if (Array.isArray(value)) return value.map((v) => flattenText(v, depth + 1)).join('\n');
+  return ['content', 'text', 'stdout', 'output', 'file'].map((k) => flattenText(value[k], depth + 1)).filter(Boolean).join('\n');
+}
+
+// A host-backgrounded run completes OUTSIDE any tool event the hooks see (a task-notification system
+// event). The supported capture is the host-written task output file: when the agent Reads
+// `.../tasks/<id>.output` and its LAST line is the host footer `[exited with code N]`, that status is the
+// runner's exit status. It is bound to the launch receipt by `backgroundTaskId` (same task ledger, so a
+// completion for another task/session finds no launch), counted once, and judged against the tree that
+// was tested at LAUNCH. A bare "passed" line, a partial read, or a path whose id has no launch is no proof.
+async function backgroundCompletionFor({ projectRoot, payload, toolInput, toolResponse }) {
+  const file = String(toolInput?.file_path || toolInput?.path || '');
+  const id = /[\\/]tasks[\\/]([A-Za-z0-9_-]+)\.output$/.exec(file)?.[1];
+  if (!id) return null;
+  const tail = flattenText(toolResponse).replace(/\s+$/, '');
+  const footer = /\[exited with code (-?\d+)\]$/.exec(tail);
+  if (!footer) return { rejected: 'no-exit-footer' };
+  const ledger = await readExecutionLedger(projectRoot, payload);
+  const receipts = ledger?.receipts || [];
+  const launch = receipts.find((r) => r.kind === 'verification' && r.backgroundTaskId === id && !r.backgroundCompletion);
+  if (!launch) return { rejected: 'no-matching-launch' };
+  if (receipts.some((r) => r.backgroundCompletion === id)) return { rejected: 'duplicate-completion' };
+  let mtime = null;
+  try { mtime = fsSync.statSync(file).mtimeMs; } catch { return { rejected: 'output-file-missing' }; }
+  if (mtime + 2000 < launch.ts) return { rejected: 'output-predates-launch' };
+  const exitCode = Number(footer[1]);
+  const success = exitCode === 0;
+  const lv = launch.verdict || {};
+  const kind = success ? (isTestGateCommand(launch.command) ? 'test-verified' : 'check-only') : 'failed';
+  return {
+    kind: 'verification', command: launch.command, success, exitCode, backgroundCompletion: id,
+    ...(launch.scope ? { scope: launch.scope } : {}),
+    ...(launch.workspaceFp ? { workspaceFp: launch.workspaceFp } : {}),
+    verdict: { ...lv, kind, evidence: launch.command, verifier: lv.verifier || 'self', ts: new Date().toISOString() },
+  };
+}
+
 function noteUnprovenExitStatus(stage) {
   if (!ledgerMessageEmitter) return;
   const message =
@@ -803,7 +853,7 @@ function compactReceipt(receipt) {
     kind: receipt.kind,
     success: receipt.success,
   };
-  for (const key of ['toolName', 'toolUseId', 'file', 'command', 'exitCode', 'scope', 'error', 'verdict', 'evidence', 'evidenceSurface', 'class', 'status', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence', 'exitStatusUnproven', 'agentId', 'agentType', 'contentSha']) {
+  for (const key of ['toolName', 'toolUseId', 'file', 'command', 'exitCode', 'scope', 'error', 'verdict', 'evidence', 'evidenceSurface', 'class', 'status', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence', 'exitStatusUnproven', 'backgroundTaskId', 'backgroundCompletion', 'agentId', 'agentType', 'contentSha']) {
     if (receipt[key] !== undefined && receipt[key] !== null && receipt[key] !== '') {
       compact[key] = key === 'operation' ? compactOperation(receipt[key]) : receipt[key];
     }
@@ -1728,7 +1778,7 @@ function newEventId() {
   return `${Date.now().toString(36)}-${crypto.randomBytes(8).toString('hex')}`;
 }
 
-const JOURNAL_RECEIPT_FIELDS = ['ts', 'kind', 'toolName', 'toolUseId', 'success', 'exitCode', 'file', 'command', 'scope', 'workspaceFp', 'workspaceRoot', 'workspaceHeadTs', 'bashReadOnly', 'exitStatusUnproven', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence', 'agentId', 'agentType', 'contentSha', 'handback', 'review', 'verdict'];
+const JOURNAL_RECEIPT_FIELDS = ['ts', 'kind', 'toolName', 'toolUseId', 'success', 'exitCode', 'file', 'command', 'scope', 'workspaceFp', 'workspaceRoot', 'workspaceHeadTs', 'bashReadOnly', 'exitStatusUnproven', 'backgroundTaskId', 'backgroundCompletion', 'detail', 'operation', 'transportSuccess', 'taskInstanceId', 'sessionKey', 'sequence', 'agentId', 'agentType', 'contentSha', 'handback', 'review', 'verdict'];
 
 // TASK-009 (BL-011): evidence attestations are whitelisted verbatim — class /
 // surface / result / claim, the ARCH §Evidence Schema fields a receipt may
@@ -3150,13 +3200,17 @@ export async function recordExecutionReceipt({
   // command has not finished, so that response carries no exit status. It must never mint
   // verification or operation evidence (completion arrives later, outside this tool event).
   const backgroundLaunchAck = toolName === 'Bash' && isBackgroundLaunchAck(toolResponse);
+  const bgCompletion = toolName === 'Read'
+    ? await backgroundCompletionFor({ projectRoot, payload, toolInput, toolResponse }) : null;
   const nativeGoal = routeState?.routeSummary?.executionContract?.operationGoal;
   const operationReceipt = backgroundLaunchAck ? null : cronOperationReceipt(toolName, toolInput, toolResponse, success, { sessionId: explicitSessionId(payload), harness })
     || (toolName === 'Bash' && !bashScope.foreign
       ? (bashOperationReceipt(toolInput.command, toolResponse, success, nativeGoal, { sessionId: explicitSessionId(payload), harness })
         || releaseOperationReceipt(toolInput.command, toolResponse, success, { sessionId: explicitSessionId(payload), harness }))
       : null);
-  if (operationReceipt) {
+  if (bgCompletion && !bgCompletion.rejected) {
+    Object.assign(receipt, bgCompletion);
+  } else if (operationReceipt) {
     Object.assign(receipt, operationReceipt);
   } else if (toolName === 'Read' || toolName === 'Grep' || toolName === 'Glob') {
     receipt.kind = 'source';
@@ -3182,6 +3236,7 @@ export async function recordExecutionReceipt({
     receipt.command = String(toolInput.command || '').trim();
     // A pipe-masked runner status (exit 0 from `| tail`) is not evidence of a pass.
     const maskedStage = isVerificationCommand(toolInput.command) ? maskedVerificationStage(toolInput.command) : null;
+    if (backgroundLaunchAck) receipt.backgroundTaskId = backgroundTaskIdOf(toolResponse);
     if (backgroundLaunchAck && receipt.success) {
       receipt.success = false;
       receipt.exitStatusUnproven = true;
@@ -3243,7 +3298,8 @@ export async function recordExecutionReceipt({
     }
   }
   if (workspaceFp) {
-    receipt.workspaceFp = workspaceFp;
+    // A background completion is judged against the tree that was tested at LAUNCH, never today's tree.
+    receipt.workspaceFp = bgCompletion && !bgCompletion.rejected && bgCompletion.workspaceFp ? bgCompletion.workspaceFp : workspaceFp;
     if (workspaceRoot !== projectRoot) {
       receipt.workspaceRoot = workspaceRoot;
       const ct = Number(gitOutput(['log', '-1', '--format=%ct'], workspaceRoot));
@@ -3712,8 +3768,12 @@ export function promptOrdersNpmPublish(state = {}) {
           const releaseOrder = /^(?:please\s+|just\s+|now\s+|also\s+)*(?:release|ship|publish)\s+(?!readiness\b|verification\b|evidence\b|policy\b|intent\b|notes\b|terminology\b)\S/.test(item);
           const releaseReference = /\b(?:release|publish|publication)\b/.test(item);
           if (negated && releaseReference && !/--dry-run/.test(item)) prohibited = true;
-          if (!negated && (releaseOrder || (publication && (
-            /^npm\s+publish\b/.test(item) || PUBLISH_ORDER_IMPERATIVE.test(item)
+          // Politeness/sequencing prefixes ("please npm publish ...") and Vietnamese verbs ("dua ... len npm",
+          // "phat hanh ... len npm") are still affirmative orders when nothing negates them.
+          const politeItem = item.replace(/^(?:(?:please|just|now|also|then|vui long|hay)\s+)+/, '');
+          const viPublish = /^(?:dua|phat hanh|xuat ban|deploy|day)\b[^.]{0,60}\b(?:len|to|vao)\s+npm\b/.test(politeItem);
+          if (!negated && (releaseOrder || viPublish || (publication && (
+            /^npm\s+publish\b/.test(politeItem) || PUBLISH_ORDER_IMPERATIVE.test(item)
             || /\b(?:chay|run)\s+`?npm\s+publish\b/.test(item)
             || /continue the release workflow:/.test(item))))) ordered = true;
         }
@@ -4503,6 +4563,14 @@ export async function reconcileStaleContract(projectRoot, state) {
     if (!fresh?.taskKind || contractSignature(fresh) === contractSignature(stored)) return state;
     const base = { ...stored };
     for (const key of CLASSIFIER_OWNED_FIELDS) delete base[key];
+    // Evidence tags added by the stale classification (operation-verification, report-artifact, ...) do not
+    // describe the re-derived kind: restart from the execution mode's base evidence unless the fresh kind
+    // sets its own (MIXED/OPERATIONAL/DOCUMENTATION/READ_ONLY are rewritten by applyTaskSemantics).
+    if (fresh.taskKind === 'CODE_IMPLEMENTATION' || (fresh.taskKind === 'CONFIGURATION' && fresh.configurationScope !== 'external')) {
+      const mode = state.routeSummary?.executionMode === 'informational' ? 'local-build' : state.routeSummary?.executionMode;
+      const baseEvidence = resolver.buildExecutionContract(mode)?.completionEvidence;
+      if (Array.isArray(baseEvidence)) base.completionEvidence = baseEvidence;
+    }
     return { ...state, routeSummary: { ...state.routeSummary, executionContract: resolver.applyTaskSemantics(base, fresh) } };
   } catch { return state; }
 }