@ngockhoale/ukit 3.4.63 → 3.4.64

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to UKit are documented here.
 
+## 3.4.64 - 2026-10-22
+
+**Completion Gate: defect-contingent repair/release is not an unconditional publish order.**
+- Exact approved pilot prompt reproduced false `release-publication`: line/comma splitting detached `release npm` from the preceding wrapped “Nếu gặp bug UKit…” condition. Standing policy/carryover is not needed to reproduce it.
+- Preserve defect-repair sentence scope across line wraps; activate its release branch only after owned runtime writes. Direct publish commands still require registry verification, and foreign-task proofs remain rejected.
+- Do not interpret hashed write-bank keys as paths; bank the runtime-write classification separately across same-task rekeys. Docs/test-only direct writes do not activate repair publication. Legacy pathless Bash deltas remain conservative (may demand release); no new path-attribution architecture added.
+- Pilot preflight narrowed to existing host interfaces and exact condition-change options; no paid arms, no relaxed limits adopted, no BAGuide/default changes.
+
 ## 3.4.63 - 2026-10-22
 
 **Completion recovery: background pending is not a pipeline.**

package/package.json

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

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

@@ -1513,6 +1513,7 @@ function carriedEvidenceLedger(fresh, current) {
     writeAttempted: fresh.writeAttempted || current.writeAttempted === true,
     writeSucceeded: fresh.writeSucceeded || current.writeSucceeded === true,
     // undefined (a ledger written before this field existed) keeps the legacy any-write behavior.
+    conditionalRuntimeWrite: fresh.conditionalRuntimeWrite === true || current.conditionalRuntimeWrite === true,
     substantiveWrite: fresh.substantiveWrite === true || current.substantiveWrite === true
       ? true
       : (current.substantiveWrite === undefined && current.writeSucceeded === true ? undefined : false),
@@ -1982,13 +1983,13 @@ async function quarantineJournalLines(target, lines) {
 
 // Uniform applier: returns { ledger, value } or null when the record is unappliable
 // (the caller quarantines it instead of applying it).
-function applyJournalRecord(ledger, record) {
+function applyJournalRecord(ledger, record, projectRoot) {
   const sameTask = ledger.taskInstanceId || record.taskInstanceId
     ? Boolean(ledger.taskInstanceId && ledger.taskInstanceId === record.taskInstanceId)
     : Boolean(ledger.requestKey && ledger.requestKey === record.requestKey && (ledger.promptKey || null) === (record.promptKey || null));
   if (!sameTask) return null;
   if (record.type === 'receipt') {
-    return applyReceiptToLedger(ledger, record.event?.receipt, { vibecode: record.event?.vibecode === true });
+    return applyReceiptToLedger(ledger, record.event?.receipt, { vibecode: record.event?.vibecode === true, projectRoot });
   }
   if (record.type === 'continuation') {
     return { ledger: applyContinuationToLedger(ledger, record.event), value: null };
@@ -2008,7 +2009,7 @@ function applyJournalRecord(ledger, record) {
 // Read the journal and apply every unseen record onto `ledger` IN MEMORY. The journal is
 // consumed only after the caller's ledger write lands (commit()), so a crash anywhere
 // before that leaves the journal intact and the records re-apply idempotently by eventId.
-async function drainJournal(target, { ledger, payload, signal, deadlineMs }) {
+async function drainJournal(target, { ledger, payload, signal, deadlineMs, projectRoot }) {
   const journalPath = journalPathFor(target);
   let text = null;
   try {
@@ -2031,7 +2032,7 @@ async function drainJournal(target, { ledger, payload, signal, deadlineMs }) {
       continue;
     }
     if (seen.has(record.eventId)) continue; // idempotent replay
-    const result = applyJournalRecord(next, record);
+    const result = applyJournalRecord(next, record, projectRoot);
     if (!result) {
       malformed.push(line);
       continue;
@@ -2529,7 +2530,7 @@ function applyReceiptToLedger(ledger, receipt, options = {}) {
   return applyReceiptCore(base, receipt, options);
 }
 
-function applyReceiptCore(ledger, receipt, { vibecode = false } = {}) {
+function applyReceiptCore(ledger, receipt, { vibecode = false, projectRoot } = {}) {
   if (!receipt || typeof receipt !== 'object' || !RECEIPT_KINDS.has(receipt.kind)) return null;
   const next = { ...ledger, receiptSequence: Number(ledger.receiptSequence || 0) + 1 };
   if (receipt.kind === 'delegation-violation') {
@@ -2565,6 +2566,7 @@ function applyReceiptCore(ledger, receipt, { vibecode = false } = {}) {
   } else if (receipt.kind === 'write') {
     next.writeAttempted = true;
     next.writeSucceeded = next.writeSucceeded || receipt.success;
+    if (receipt.success && isConditionalRuntimeWrite(receipt, receipt.workspaceRoot || projectRoot)) next.conditionalRuntimeWrite = true;
     if (receipt.success && receipt.file && !isBookkeepingWrite(receipt.file)) next.substantiveWrite = true;
     else if (next.substantiveWrite === undefined) next.substantiveWrite = false;
     // Evidence tier: a fingerprint-derived Bash delta is inferred (supporting) evidence; only a
@@ -2946,7 +2948,7 @@ export async function recordLedgerEvent(event, {
     let ledger = liveBaseLedger(event, current, payload, state, harness, fallbackLedger);
     // Reconcile pending journaled events first — inside this caller's acquired lock and
     // before its own evidence, so a timed-out writer's receipt is never stranded.
-    const drained = await drainJournal(target, { ledger, payload, signal, deadlineMs });
+    const drained = await drainJournal(target, { ledger, payload, signal, deadlineMs, projectRoot });
     ledger = drained.ledger;
     let value;
     if (event.type === 'receipt') {
@@ -2975,7 +2977,7 @@ export async function recordLedgerEvent(event, {
       const stampedReceipt = TASK_OWNED_RECEIPT_KINDS.has(event.receipt.kind)
         ? { ...event.receipt, taskInstanceId: state?.taskInstanceId || null, sessionKey: sessionIdentity(payload) }
         : event.receipt;
-      const applied = applyReceiptToLedger(ledger, stampedReceipt, { vibecode: event.vibecode === true });
+      const applied = applyReceiptToLedger(ledger, stampedReceipt, { vibecode: event.vibecode === true, projectRoot });
       if (!applied) return { committed: false, eventId, reason: 'invalid-receipt' };
       ledger = applied.ledger;
       // TASK-005 (FR-005): completion receipts (write/verification terminal
@@ -3781,12 +3783,23 @@ const PUBLISH_ORDER_HEADER = /prohibit|forbidden|out of scope|non-goal|scope con
 // "Do not: ... npm publish") keeps its negation across comma/and/or list items and under a prohibition header; only a
 // explicit command can end a negated non-release clause, but bare list verbs cannot. Explicit publication
 // prohibitions win over positive references elsewhere. Only the task's authoritative prompt is consulted.
+// Keep a defect-contingent repair sentence together across soft line wraps. Its
+// publication instruction becomes active only after an owned runtime write.
+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 promptOrdersNpmPublish(state = {}) {
   const text = String(state?.routingContext?.lastExplicitUserPromptText || '')
     .normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
   // Quoted commands and historical/example blocks describe orders; they do not issue them.
-  const active = text.replace(/```[^]*?```|~~~[^]*?~~~/g, '')
+  let active = text.replace(/```[^]*?```|~~~[^]*?~~~/g, '')
     .replace(/^[ \t]*>.*$/gm, '').replace(/[“"][^”"\n]*[”"]|‘[^’\n]*’/g, '');
+  for (const branch of defectRepairBranches(active)) active = active.replace(branch, '');
   let prohibited = false;
   let ordered = false;
   let blockNegated = false;
@@ -3821,6 +3834,16 @@ export function promptOrdersNpmPublish(state = {}) {
   return ordered && !prohibited;
 }
 
+function isConditionalRuntimeWrite(receipt, cwd) {
+  if (receipt.kind !== 'write' || receipt.success !== true || !receipt.file || isBookkeepingWrite(receipt.file)) return false;
+  // Older inferred Bash deltas have no paths: keep their conservative release demand.
+  if (receipt.detail === 'bash-workspace-delta' && /^bash-workspace:/.test(receipt.file)) return true;
+  const relative = cwd ? path.relative(path.resolve(cwd), path.resolve(cwd, receipt.file)) : String(receipt.file);
+  if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`)) return false;
+  return !/^(?:\.ukit|\.cache|node_modules|docs|tests?|fixtures?)(?:[\\/]|$)/.test(relative)
+    && !/^tmp(?:[\\/]|$)/.test(relative);
+}
+
 // Conditional repair is not a publication order until owned project source actually changes.
 // Reuse the affirmative publication parser on the taken branch, including its negation rules.
 function conditionalRepairOrdersPublish(state, ledger, cwd) {
@@ -3828,21 +3851,22 @@ function conditionalRepairOrdersPublish(state, ledger, cwd) {
   const text = String(state?.routingContext?.lastExplicitUserPromptText || '')
     .normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
     .replace(/```[^]*?```|~~~[^]*?~~~/g, '').replace(/^[ \t]*>.*$/gm, '');
-  if (!/(?:^|\n)[ \t*#_-]*(?:muc tieu|goal|purpose|objective)\s*:[^\n]*\b(?:xac nhan|verify|confirm|validate)\b/.test(text)) return false;
-  const branch = text.match(/(?:^|\n|\.\s+)[ \t]*(?:\d+[.)]\s*)?(?:neu\s+co\s+source fix|if\s+(?:there is a\s+)?source fix)\s*:[^\n]*/)?.[0];
-  if (!branch) return false;
-  const writes = [...(ledger.receipts || []), ...Object.keys(ledger.bankedWrites || {}).map((file) => ({ kind: 'write', success: true, file }))];
-  const projectWrite = writes.some((receipt) => {
-    if (receipt.kind !== 'write' || receipt.success !== true || !receipt.file || isBookkeepingWrite(receipt.file)) return false;
-    if (receipt.detail === 'bash-workspace-delta' && /^bash-workspace:/.test(receipt.file)) return true;
-    const relative = path.relative(path.resolve(cwd), path.resolve(cwd, receipt.file));
-    return relative && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative)
-      && !/^(?:\.ukit|\.cache|node_modules|tests?|fixtures?|tmp)(?:[\\/]|$)/.test(relative);
-  });
+  const defectBranches = defectRepairBranches(text);
+  const verificationPurpose = /(?:^|\n)[ \t*#_-]*(?:muc tieu|goal|purpose|objective)\s*:[^\n]*\b(?:xac nhan|verify|confirm|validate)\b/.test(text);
+  const legacyBranch = verificationPurpose ? text.match(/(?:^|\n|\.\s+)[ \t]*(?:\d+[.)]\s*)?(?:neu\s+co\s+source fix|if\s+(?:there is a\s+)?source fix)\s*:[^\n]*/)?.[0] : null;
+  if (!defectBranches.length && !legacyBranch) return false;
+  // bankedWrites keys are hashes, never filenames. Keep the runtime-write bit
+  // separately so receipt-window eviction cannot activate a report-only branch.
+  const projectWrite = ledger.conditionalRuntimeWrite === true
+    || (ledger.receipts || []).some((receipt) => isConditionalRuntimeWrite(receipt, cwd));
   if (!projectWrite) return false;
   // Explicit task-wide publication prohibitions still dominate the conditional branch.
   if (/(?:do not|never|khong|chua)\s+(?:npm\s+)?publish\b|\bno\s+(?:release|publication)\b/.test(text)) return false;
-  return promptOrdersNpmPublish({ routingContext: { lastExplicitUserPromptText: branch.replace(/^.*?:/, 'Run ') } });
+  return defectBranches.some((branch) => promptOrdersNpmPublish({ routingContext: {
+    lastExplicitUserPromptText: branch.replace(/^[^,\n]*[,\n]\s*/, '').replace(/\s*\n\s*/g, ' '),
+  } })) || Boolean(legacyBranch && promptOrdersNpmPublish({ routingContext: {
+    lastExplicitUserPromptText: legacyBranch.replace(/^.*?:/, 'Run '),
+  } }));
 }
 
 function releasePublicationMissing(state, ledger, cwd) {