@ngockhoale/ukit 3.4.62 → 3.4.64

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 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.**
+- Reproduced task `task-848c14831946f7c359cdf11faf45edd2` / `bk1n4wpks`: bare release verifier exited 0 in host notification; Bash/grep read did not ingest completion. Launch and masked-shell receipts share `exitStatusUnproven`; recovery falsely asserted pipeline and requested reruns.
+- Diagnostic-only fix: background launch -> wait SAME job, no duplicate; host completion -> Read task output through footer, not rerun; masked shell -> wrapper status unproven, actual pipe only a possible cause. Receipt acceptance/freshness unchanged; unsupported hosts remain fail-closed.
+- Regressions: pending, host completion+Bash vs Read, later launch not masking valid completion, failed runner, masked wrapper, analysis-doc freshness vs living STATUS; existing forged/mismatched/duplicate/foreign/stale controls retained.
+- Release-gate fixture repair: TERM-ignoring grandchild now signals readiness after handler installation before the measured runner deadline starts (injected real child); retains ≥700ms grace/escalation and no-survivor assertions. Production hook-process unchanged.
+- Independent four-task fixture pilot and whole-workflow budget proposal recorded; no paid pilot. OMP genuine-service live smoke remains unverified (deterministic RPC bash lacks name/ready); no claim of every-service coverage.
+
 ## 3.4.62 - 2026-10-22
 
 **Handoff commands: state what `handoff.maxParallelAgents` counts (wording only).**

package/manifests/documentation.yaml

@@ -462,6 +462,17 @@ entries:
     validation: [manual]
     archive_policy: replace-with-snapshot
     notes: continuity checkpoint for the concurrency audit (R6 corrections, bash guard, prepared unpaid pilot)
+  - id: docs-analysis-concurrency-pilot
+    path: docs/analysis/concurrency-pilot/README.md
+    class: canonical
+    audience: [owner, maintainer]
+    owner: runtime
+    source_of_truth: docs/analysis/concurrency-pilot/README.md
+    merge_strategy: none
+    load_policy: on-demand
+    validation: [manual]
+    archive_policy: replace-with-snapshot
+    notes: independent frozen fixture pilot proposal; no paid run
   - id: docs-analysis-subagent-cost-audit
     path: docs/analysis/SUBAGENT-COST-AUDIT.md
     class: archive

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.62",
+  "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
@@ -3268,7 +3270,9 @@ export async function recordExecutionReceipt({
     if (backgroundLaunchAck && receipt.success) {
       receipt.success = false;
       receipt.exitStatusUnproven = true;
-      noteUnprovenExitStatus(`${String(toolInput.command || '').trim().slice(0, 60)} (background launch)`);
+      if (ledgerMessageEmitter) {
+        try { ledgerMessageEmitter(`${JSON.stringify({ systemMessage: `UKit execution-ledger: background verification ${receipt.backgroundTaskId || '(unknown id)'} is pending. Wait for the same job; do not launch a duplicate. After the host task-notification, Read its tasks/<id>.output through the final exit footer to ingest completion; Bash/grep does not ingest it.` })}\n`); } catch { /* advisory */ }
+      }
     } else if (maskedStage && receipt.success) {
       receipt.success = false;
       receipt.exitStatusUnproven = true;
@@ -3605,7 +3609,15 @@ function recoveryInstruction(missingEvidence, ledger = {}, routeSummary = {}, {
     // Unproven never sets `verificationFailed`, so this must not key off that flag.
     const lastVerification = [...(ledger.receipts || [])].reverse().find((r) => r?.kind === 'verification');
     if (!instruction && lastVerification?.exitStatusUnproven === true) {
-      instruction = `The last verification (\`${String(lastVerification.command || '').slice(0, 80)}\`) ran in a pipeline, so its exit status is unproven. Re-run it without the pipe, or with \`set -o pipefail\`, and inspect the exit code.`;
+      if (lastVerification.backgroundTaskId && !lastVerification.backgroundCompletion) {
+        const id = lastVerification.backgroundTaskId;
+        const hostExit = hostCompletionExit(ledger.transcriptPath, id);
+        instruction = hostExit === null
+          ? `Background verification ${id} has no ingested completion (pending or unsupported host evidence). Wait for the same job and its host task-notification; do not launch a duplicate. Then use Read on its tasks/${id}.output through the final exit footer. Bash/grep does not ingest completion; a footer without a matching host notification is not proof.`
+          : `Background verification ${id} has host completion exit ${hostExit}, but no ingested completion receipt. Use Read on its tasks/${id}.output through the final exit footer (Bash/grep does not ingest completion). Do not rerun the completed job just to create evidence. If Read is rejected, check the matching launch, host notification, footer and output-file freshness; never fabricate a receipt.`;
+      } else {
+        instruction = `The last verification (\`${String(lastVerification.command || '').slice(0, 80)}\`) exit status is unproven: its shell wrapper may mask or skip the runner (a pipeline is one possible cause). Run the bare verification command and inspect its exit code; for an actual pipeline, propagate the runner status with \`set -o pipefail\`.`;
+      }
     }
     if (!instruction && ledger.verificationFailed) {
       instruction = 'Use the latest failed verification output, fix the failure, and rerun targeted verification.';
@@ -3771,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;
@@ -3811,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) {
@@ -3818,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) {